2015-10-21 05:01:47 -05:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
|
|
|
|
/*
|
|
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
*/
|
|
|
|
|
2021-01-19 20:40:54 -06:00
|
|
|
#include <chrono>
|
|
|
|
#include <string>
|
2019-03-04 15:02:59 -06:00
|
|
|
#define TST_LOG_REDIRECT
|
2017-12-20 07:06:26 -06:00
|
|
|
#include <test.hpp>
|
2017-06-19 07:55:07 -05:00
|
|
|
|
2017-12-20 07:06:26 -06:00
|
|
|
#include <config.h>
|
2017-03-08 10:38:22 -06:00
|
|
|
|
2016-10-12 03:47:26 -05:00
|
|
|
#include <cstdlib>
|
2015-10-21 05:01:47 -05:00
|
|
|
#include <iostream>
|
2019-09-12 04:43:49 -05:00
|
|
|
#include <memory>
|
2016-08-28 15:32:34 -05:00
|
|
|
|
|
|
|
#include <cppunit/BriefTestProgressListener.h>
|
|
|
|
#include <cppunit/CompilerOutputter.h>
|
2015-10-21 05:01:47 -05:00
|
|
|
#include <cppunit/TestResult.h>
|
2019-05-01 16:12:56 -05:00
|
|
|
#include <cppunit/TestFailure.h>
|
2015-10-21 05:01:47 -05:00
|
|
|
#include <cppunit/TestResultCollector.h>
|
2016-08-28 15:32:34 -05:00
|
|
|
#include <cppunit/TestRunner.h>
|
2016-03-25 18:41:53 -05:00
|
|
|
#include <cppunit/TextTestProgressListener.h>
|
2015-10-21 05:01:47 -05:00
|
|
|
#include <cppunit/extensions/TestFactoryRegistry.h>
|
2016-08-28 15:32:34 -05:00
|
|
|
|
|
|
|
#include <Poco/RegularExpression.h>
|
2017-09-19 15:16:44 -05:00
|
|
|
#include <Poco/DirectoryIterator.h>
|
|
|
|
#include <Poco/FileStream.h>
|
|
|
|
#include <Poco/StreamCopier.h>
|
2015-10-21 05:01:47 -05:00
|
|
|
|
2020-02-23 12:32:10 -06:00
|
|
|
#include <helpers.hpp>
|
2020-01-21 05:21:08 -06:00
|
|
|
#include <Unit.hpp>
|
2021-11-18 06:08:14 -06:00
|
|
|
#include <wsd/COOLWSD.hpp>
|
2021-01-10 08:59:36 -06:00
|
|
|
#if ENABLE_SSL
|
|
|
|
#include <Ssl.hpp>
|
|
|
|
#include <SslSocket.hpp>
|
|
|
|
#endif
|
2016-09-14 16:43:56 -05:00
|
|
|
#include <Log.hpp>
|
|
|
|
|
2019-11-13 00:48:30 -06:00
|
|
|
#include "common/Protocol.hpp"
|
|
|
|
|
2016-04-24 19:59:58 -05:00
|
|
|
class HTTPGetTest;
|
|
|
|
|
2018-10-17 02:34:05 -05:00
|
|
|
bool filterTests(CPPUNIT_NS::TestRunner& runner, CPPUNIT_NS::Test* testRegistry, const std::string& testName)
|
2015-10-21 05:01:47 -05:00
|
|
|
{
|
2016-10-17 10:51:54 -05:00
|
|
|
Poco::RegularExpression re(testName, Poco::RegularExpression::RE_CASELESS);
|
|
|
|
Poco::RegularExpression::Match reMatch;
|
2016-08-28 15:32:34 -05:00
|
|
|
|
2016-10-17 10:51:54 -05:00
|
|
|
bool haveTests = false;
|
|
|
|
for (int i = 0; i < testRegistry->getChildTestCount(); ++i)
|
|
|
|
{
|
|
|
|
CPPUNIT_NS::Test* testSuite = testRegistry->getChildTestAt(i);
|
|
|
|
for (int j = 0; j < testSuite->getChildTestCount(); ++j)
|
2016-07-08 02:04:27 -05:00
|
|
|
{
|
2016-10-17 10:51:54 -05:00
|
|
|
CPPUNIT_NS::Test* testCase = testSuite->getChildTestAt(j);
|
|
|
|
try
|
2016-07-08 02:04:27 -05:00
|
|
|
{
|
2016-10-17 10:51:54 -05:00
|
|
|
if (re.match(testCase->getName(), reMatch))
|
2016-08-28 15:32:34 -05:00
|
|
|
{
|
2016-10-17 10:51:54 -05:00
|
|
|
runner.addTest(testCase);
|
|
|
|
haveTests = true;
|
2016-08-28 15:32:34 -05:00
|
|
|
}
|
2016-07-08 02:04:27 -05:00
|
|
|
}
|
2016-10-17 10:51:54 -05:00
|
|
|
catch (const std::exception& exc)
|
|
|
|
{
|
|
|
|
// Nothing to do; skip.
|
|
|
|
}
|
2016-07-08 02:04:27 -05:00
|
|
|
}
|
|
|
|
}
|
2016-08-28 15:32:34 -05:00
|
|
|
|
2016-10-17 10:51:54 -05:00
|
|
|
return haveTests;
|
2016-08-28 15:32:34 -05:00
|
|
|
}
|
|
|
|
|
2019-08-29 02:00:16 -05:00
|
|
|
static bool IsDebugrun = false;
|
|
|
|
|
2017-04-07 08:37:20 -05:00
|
|
|
int main(int argc, char** argv)
|
2016-08-28 15:32:34 -05:00
|
|
|
{
|
2019-09-22 11:37:32 -05:00
|
|
|
bool verbose = false;
|
2021-11-18 06:08:14 -06:00
|
|
|
std::string cert_path = "/etc/coolwsd/";
|
2019-09-22 11:37:32 -05:00
|
|
|
for (int i = 1; i < argc; ++i)
|
|
|
|
{
|
|
|
|
const std::string arg(argv[i]);
|
|
|
|
if (arg == "--verbose")
|
|
|
|
{
|
|
|
|
verbose = true;
|
|
|
|
}
|
|
|
|
else if (arg == "--debugrun")
|
|
|
|
{
|
|
|
|
IsDebugrun = true;
|
|
|
|
}
|
2021-01-10 08:59:36 -06:00
|
|
|
else if (arg == "--cert-path" && ++i < argc)
|
|
|
|
{
|
|
|
|
cert_path = argv[i];
|
|
|
|
}
|
2019-09-22 11:37:32 -05:00
|
|
|
}
|
2017-04-07 08:37:20 -05:00
|
|
|
|
2019-09-22 11:37:32 -05:00
|
|
|
const char* loglevel = verbose ? "trace" : "warning";
|
2021-03-15 15:57:17 -05:00
|
|
|
const bool withColor = isatty(fileno(stderr));
|
|
|
|
Log::initialize("tst", loglevel, withColor, false, {});
|
2016-09-14 16:43:56 -05:00
|
|
|
|
2021-01-10 08:59:36 -06:00
|
|
|
#if ENABLE_SSL
|
|
|
|
try
|
|
|
|
{
|
|
|
|
// The most likely place. If not found, SSL will be disabled in the tests.
|
|
|
|
const std::string ssl_cert_file_path = cert_path + "/cert.pem";
|
|
|
|
const std::string ssl_key_file_path = cert_path + "/key.pem";
|
|
|
|
const std::string ssl_ca_file_path = cert_path + "/ca-chain.cert.pem";
|
|
|
|
const std::string ssl_cipher_list = "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH";
|
|
|
|
|
|
|
|
// Initialize the non-blocking socket SSL.
|
2021-06-23 20:30:28 -05:00
|
|
|
ssl::Manager::initializeServerContext(ssl_cert_file_path, ssl_key_file_path,
|
2021-06-27 14:22:17 -05:00
|
|
|
ssl_ca_file_path, ssl_cipher_list,
|
|
|
|
ssl::CertificateVerification::Disabled);
|
2021-06-28 23:15:04 -05:00
|
|
|
|
|
|
|
ssl::Manager::initializeClientContext(ssl_cert_file_path, ssl_key_file_path,
|
|
|
|
ssl_ca_file_path, ssl_cipher_list,
|
|
|
|
ssl::CertificateVerification::Required);
|
2021-01-10 08:59:36 -06:00
|
|
|
}
|
|
|
|
catch (const std::exception& ex)
|
|
|
|
{
|
|
|
|
LOG_ERR("Exception while initializing SslContext: " << ex.what());
|
|
|
|
}
|
|
|
|
|
2021-06-23 20:30:28 -05:00
|
|
|
if (!ssl::Manager::isServerContextInitialized())
|
2021-06-28 23:15:04 -05:00
|
|
|
LOG_ERR("Failed to initialize Server SSL. Set the path to the certificates via "
|
|
|
|
"--cert-path. HTTPS tests will be disabled in unit-tests.");
|
|
|
|
else
|
|
|
|
LOG_INF("Initialized Server SSL.");
|
|
|
|
|
|
|
|
if (!ssl::Manager::isClientContextInitialized())
|
|
|
|
LOG_ERR("Failed to initialize Client SSL.");
|
2021-03-23 12:49:34 -05:00
|
|
|
else
|
2021-06-28 23:15:04 -05:00
|
|
|
LOG_INF("Initialized Client SSL.");
|
2021-03-23 12:49:34 -05:00
|
|
|
#else
|
|
|
|
LOG_INF("SSL is unsupported in this build.");
|
2021-01-10 08:59:36 -06:00
|
|
|
#endif
|
|
|
|
|
2022-08-12 06:24:41 -05:00
|
|
|
return runClientTests(argv[0], true, verbose) ? 0 : 1;
|
2017-05-11 21:08:20 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool IsStandalone = false;
|
|
|
|
|
|
|
|
bool isStandalone()
|
|
|
|
{
|
|
|
|
return IsStandalone;
|
|
|
|
}
|
|
|
|
|
2020-02-23 12:32:10 -06:00
|
|
|
static std::mutex ErrorMutex;
|
2019-05-04 14:16:36 -05:00
|
|
|
static bool IsVerbose = false;
|
2020-02-23 12:32:10 -06:00
|
|
|
static std::ostringstream ErrorsStream;
|
2019-03-04 15:02:59 -06:00
|
|
|
|
|
|
|
void tstLog(const std::ostringstream &stream)
|
|
|
|
{
|
2019-05-04 14:16:36 -05:00
|
|
|
if (IsVerbose)
|
2020-02-23 12:32:10 -06:00
|
|
|
writeTestLog(stream.str() + '\n');
|
2019-05-04 14:16:36 -05:00
|
|
|
else
|
|
|
|
{
|
2020-02-23 12:32:10 -06:00
|
|
|
std::lock_guard<std::mutex> lock(ErrorMutex);
|
|
|
|
ErrorsStream << stream.str();
|
2019-05-04 14:16:36 -05:00
|
|
|
}
|
2019-03-04 15:02:59 -06:00
|
|
|
}
|
|
|
|
|
2020-02-23 12:32:10 -06:00
|
|
|
class TestProgressListener : public CppUnit::TestListener
|
|
|
|
{
|
|
|
|
TestProgressListener(const TestProgressListener& copy) = delete;
|
|
|
|
void operator=(const TestProgressListener& copy) = delete;
|
|
|
|
|
|
|
|
public:
|
|
|
|
TestProgressListener() {}
|
|
|
|
virtual ~TestProgressListener() {}
|
|
|
|
|
|
|
|
void startTest(CppUnit::Test* test)
|
|
|
|
{
|
2021-01-19 20:40:54 -06:00
|
|
|
writeTestLog("\n=============== START " + test->getName() + '\n');
|
2021-04-12 13:39:46 -05:00
|
|
|
if (UnitBase::isUnitTesting()) // Only if we are in UnitClient.
|
|
|
|
UnitBase::get().setTestname(test->getName());
|
2021-01-19 20:40:54 -06:00
|
|
|
_startTime = std::chrono::steady_clock::now();
|
2020-02-23 12:32:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void addFailure(const CppUnit::TestFailure& failure)
|
|
|
|
{
|
|
|
|
if (failure.isError())
|
2020-11-15 12:42:37 -06:00
|
|
|
writeTestLog("\n>>>>>>>> ERROR " + failure.failedTestName() + " <<<<<<<<<\n");
|
2020-02-23 12:32:10 -06:00
|
|
|
else
|
2020-11-15 12:42:37 -06:00
|
|
|
writeTestLog("\n>>>>>>>> FAILED " + failure.failedTestName() + " <<<<<<<<<\n");
|
|
|
|
|
|
|
|
const auto ex = failure.thrownException();
|
|
|
|
if (ex != nullptr)
|
|
|
|
{
|
|
|
|
writeTestLog("\nException: " + ex->message().shortDescription() + '\n'
|
|
|
|
+ ex->message().details() + "\tat " + ex->sourceLine().fileName() + ':'
|
|
|
|
+ std::to_string(ex->sourceLine().lineNumber()) + '\n');
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
writeTestLog("\tat " + failure.sourceLine().fileName() + ':'
|
|
|
|
+ std::to_string(failure.sourceLine().lineNumber()) + '\n');
|
|
|
|
}
|
2020-02-23 12:32:10 -06:00
|
|
|
}
|
|
|
|
|
2021-01-19 20:40:54 -06:00
|
|
|
void endTest(CppUnit::Test* test)
|
|
|
|
{
|
|
|
|
const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
|
|
std::chrono::steady_clock::now() - _startTime);
|
|
|
|
writeTestLog("\n=============== END " + test->getName() + " (" + std::to_string(ms.count())
|
|
|
|
+ "ms) ===============\n");
|
|
|
|
}
|
2020-02-23 12:32:10 -06:00
|
|
|
|
|
|
|
private:
|
2021-01-19 20:40:54 -06:00
|
|
|
std::chrono::steady_clock::time_point _startTime;
|
2020-02-23 12:32:10 -06:00
|
|
|
};
|
|
|
|
|
2017-09-19 13:06:46 -05:00
|
|
|
// returns true on success
|
2022-08-12 06:24:41 -05:00
|
|
|
bool runClientTests(const char* cmd, bool standalone, bool verbose)
|
2017-05-11 21:08:20 -05:00
|
|
|
{
|
2019-05-04 14:16:36 -05:00
|
|
|
IsVerbose = verbose;
|
2017-05-11 21:08:20 -05:00
|
|
|
IsStandalone = standalone;
|
|
|
|
|
2016-08-28 15:32:34 -05:00
|
|
|
CPPUNIT_NS::TestResult controller;
|
|
|
|
CPPUNIT_NS::TestResultCollector result;
|
|
|
|
controller.addListener(&result);
|
2020-02-23 12:32:10 -06:00
|
|
|
TestProgressListener listener;
|
2019-09-12 04:43:49 -05:00
|
|
|
controller.addListener(&listener);
|
2016-08-28 15:32:34 -05:00
|
|
|
|
|
|
|
CPPUNIT_NS::Test* testRegistry = CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest();
|
|
|
|
|
|
|
|
CPPUNIT_NS::TestRunner runner;
|
2016-10-17 10:51:54 -05:00
|
|
|
const char* envar = std::getenv("CPPUNIT_TEST_NAME");
|
|
|
|
std::string testName;
|
|
|
|
if (envar)
|
|
|
|
{
|
|
|
|
testName = std::string(envar);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (testName.empty())
|
2016-08-28 15:32:34 -05:00
|
|
|
{
|
2016-10-17 10:51:54 -05:00
|
|
|
// Add all tests.
|
2016-08-28 15:32:34 -05:00
|
|
|
runner.addTest(testRegistry);
|
|
|
|
}
|
2016-10-17 10:51:54 -05:00
|
|
|
else
|
|
|
|
{
|
|
|
|
const bool testsAdded = filterTests(runner, testRegistry, testName);
|
|
|
|
if (!testsAdded)
|
|
|
|
{
|
|
|
|
std::cerr << "Failed to match [" << testName << "] to any names in the external test-suite. "
|
|
|
|
<< "No external tests will be executed" << std::endl;
|
|
|
|
}
|
|
|
|
}
|
2016-07-08 02:04:27 -05:00
|
|
|
|
2017-04-19 23:06:28 -05:00
|
|
|
if (!verbose)
|
|
|
|
{
|
|
|
|
runner.run(controller);
|
2015-10-21 05:01:47 -05:00
|
|
|
|
2020-02-23 12:32:10 -06:00
|
|
|
// output the ErrorsStream we got during the testing
|
2017-04-19 23:06:28 -05:00
|
|
|
if (!result.wasSuccessful())
|
2020-02-23 12:32:10 -06:00
|
|
|
writeTestLog(ErrorsStream.str() + '\n');
|
2017-04-19 23:06:28 -05:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
runner.run(controller);
|
|
|
|
}
|
2017-04-07 08:37:20 -05:00
|
|
|
|
2015-10-21 05:01:47 -05:00
|
|
|
CPPUNIT_NS::CompilerOutputter outputter(&result, std::cerr);
|
2016-10-04 03:04:22 -05:00
|
|
|
outputter.setNoWrap();
|
2015-10-21 05:01:47 -05:00
|
|
|
outputter.write();
|
|
|
|
|
2019-05-01 16:12:56 -05:00
|
|
|
const std::deque<CPPUNIT_NS::TestFailure *> &failures = result.failures();
|
|
|
|
if (!envar && failures.size() > 0)
|
|
|
|
{
|
|
|
|
std::cerr << "\nTo reproduce the first test failure use:\n\n";
|
2020-01-21 05:21:08 -06:00
|
|
|
#ifdef STANDALONE_CPPUNIT // unittest
|
|
|
|
std::cerr << "To debug:\n\n";
|
|
|
|
std::cerr << " (cd test; CPPUNIT_TEST_NAME=\"" << (*failures.begin())->failedTestName() << "\" gdb --args " << cmd << ")\n\n";
|
2019-05-03 08:01:57 -05:00
|
|
|
#else
|
2022-08-12 06:24:41 -05:00
|
|
|
(void)cmd;
|
2020-01-17 15:18:42 -06:00
|
|
|
std::string aLib = UnitBase::get().getUnitLibPath();
|
2020-11-15 11:03:45 -06:00
|
|
|
std::size_t lastSlash = aLib.rfind('/');
|
2020-01-17 15:18:42 -06:00
|
|
|
if (lastSlash != std::string::npos)
|
|
|
|
aLib = aLib.substr(lastSlash + 1, aLib.length() - lastSlash - 4) + ".la";
|
2020-01-17 14:49:38 -06:00
|
|
|
std::cerr << "(cd test; CPPUNIT_TEST_NAME=\"" << (*failures.begin())->failedTestName() <<
|
2020-01-17 15:18:42 -06:00
|
|
|
"\" ./run_unit.sh --test-name " << aLib << ")\n\n";
|
2019-05-03 08:01:57 -05:00
|
|
|
#endif
|
2019-05-01 16:12:56 -05:00
|
|
|
}
|
|
|
|
|
2017-08-17 07:04:22 -05:00
|
|
|
return result.wasSuccessful();
|
2015-10-21 05:01:47 -05:00
|
|
|
}
|
|
|
|
|
2020-01-21 05:21:08 -06:00
|
|
|
// Standalone tests don't really use WSD
|
|
|
|
#ifndef STANDALONE_CPPUNIT
|
2017-09-19 13:06:46 -05:00
|
|
|
|
2021-03-26 11:57:08 -05:00
|
|
|
std::set<pid_t> getKitPids()
|
2017-09-19 13:06:46 -05:00
|
|
|
{
|
2021-11-18 06:08:14 -06:00
|
|
|
return COOLWSD::getKitPids();
|
2017-09-19 13:06:46 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Get the PID of the forkit
|
2021-03-26 11:57:08 -05:00
|
|
|
std::set<pid_t> getForKitPids()
|
2017-09-19 13:06:46 -05:00
|
|
|
{
|
2021-03-26 11:57:08 -05:00
|
|
|
std::set<pid_t> pids;
|
2021-11-18 06:08:14 -06:00
|
|
|
if (COOLWSD::ForKitProcId >= 0)
|
|
|
|
pids.emplace(COOLWSD::ForKitProcId);
|
2017-09-19 13:06:46 -05:00
|
|
|
return pids;
|
|
|
|
}
|
|
|
|
|
2021-11-18 06:08:14 -06:00
|
|
|
/// How many live coolkit processes do we have ?
|
|
|
|
int getCoolKitProcessCount()
|
2017-09-19 13:06:46 -05:00
|
|
|
{
|
|
|
|
return getKitPids().size();
|
|
|
|
}
|
2020-01-21 05:21:08 -06:00
|
|
|
#endif
|
2017-09-19 13:06:46 -05:00
|
|
|
|
2015-10-21 05:01:47 -05:00
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|