libreoffice-online/test/UnitWSDClient.hpp

183 lines
6.7 KiB
C++
Raw Normal View History

/* -*- 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/.
*/
#include "helpers.hpp"
#include "lokassert.hpp"
#include "testlog.hpp"
#include "Unit.hpp"
#include "Util.hpp"
#include <Poco/URI.h>
#include <memory>
#include <string>
#include <vector>
/// Send a command message to WSD from a UnitWSDClient instance on the given connection.
#define WSD_CMD_BY_CONNECTION_INDEX(INDEX, MSG) \
do \
{ \
LOG_TST("Sending from #" << INDEX << ": " << MSG); \
sendCommand(INDEX, MSG); \
} while (false)
/// Send a command message to WSD from a UnitWSDClient instance on the primary connection.
#define WSD_CMD(MSG) WSD_CMD_BY_CONNECTION_INDEX(0, MSG)
/// A WebSocketSession wrapper to help with testing.
class UnitWebSocket final
{
std::shared_ptr<http::WebSocketSession> _httpSocket;
public:
/// Get a websocket connected for a given URL.
UnitWebSocket(const std::shared_ptr<SocketPoll>& socketPoll, const std::string& documentURL,
const std::string& testname = "UnitWebSocket ")
{
Poco::URI uri(helpers::getTestServerURI());
_httpSocket = helpers::connectLOKit(socketPoll, uri, documentURL, testname);
}
/// Destroy the WS.
/// Here, we can't do IO as we don't own the socket (SocketPoll does).
/// In fact, we can't destroy it (it's referenced by SocketPoll).
/// Instead, we can only flag for shutting down.
~UnitWebSocket() { _httpSocket->asyncShutdown(); }
const std::shared_ptr<http::WebSocketSession>& getWebSocket() { return _httpSocket; }
};
/// A WSD unit-test base class with support
/// to manage client connections.
/// This cannot be in UnitWSD or UnitBase because
/// we use test code that isn't availabe in COOLWSD.
class UnitWSDClient : public UnitWSD
{
public:
UnitWSDClient(const std::string& name)
: UnitWSD(name)
{
}
protected:
const std::string& getWopiSrc() const { return _wopiSrc; }
const std::unique_ptr<UnitWebSocket>& getWs() const { return _wsList.at(0); }
const std::unique_ptr<UnitWebSocket>& getWsAt(int index) { return _wsList.at(index); }
void deleteSocketAt(int index)
{
// Don't remove from the container, because the
// indexes are how the test refers to them.
std::unique_ptr<UnitWebSocket>& socket = _wsList.at(index);
socket.reset();
}
std::string initWebsocket(const std::string& wopiName)
{
const Poco::URI wopiURL(helpers::getTestServerURI() + wopiName +
"&testname=" + getTestname());
_wopiSrc = Util::encodeURIComponent(wopiURL.toString());
// This is just a client connection that is used from the tests.
LOG_TST("Connecting test client to COOL (#" << (_wsList.size() + 1)
<< " connection): /cool/" << _wopiSrc << "/ws");
// Insert at the front.
const auto& _ws = _wsList.emplace(
_wsList.begin(), std::make_unique<UnitWebSocket>(
socketPoll(), "/cool/" + _wopiSrc + "/ws", getTestname()));
assert((*_ws).get());
return _wopiSrc;
}
std::string addWebSocket(const std::string& wopiName)
{
const Poco::URI wopiURL(helpers::getTestServerURI() + wopiName +
"&testname=" + getTestname());
std::string wopiSrc = Util::encodeURIComponent(wopiURL.toString());
// This is just a client connection that is used from the tests.
LOG_TST("Connecting test client to COOL (#" << (_wsList.size() + 1)
<< " connection): /cool/" << wopiSrc << "/ws");
// Insert at the back.
const auto& _ws = _wsList.emplace(
_wsList.end(), std::make_unique<UnitWebSocket>(socketPoll(), "/cool/" + wopiSrc + "/ws",
getTestname()));
assert((*_ws).get());
return wopiSrc;
}
void addWebSocket()
{
// This is just a client connection that is used from the tests.
LOG_TST("Connecting test client to COOL (#" << (_wsList.size() + 1)
<< " connection): /cool/" << _wopiSrc << "/ws");
// Insert at the back.
const auto& _ws = _wsList.emplace(
_wsList.end(), std::make_unique<UnitWebSocket>(
socketPoll(), "/cool/" + _wopiSrc + "/ws", getTestname()));
assert((*_ws).get());
}
void endTest(const std::string& reason) override
{
LOG_TST("Ending test by disconnecting " << _wsList.size() << " connection(s): " << reason);
_wsList.clear();
UnitWSD::endTest(reason);
}
/// Send a command to WSD.
void sendCommand(int index, const std::string& msg)
{
LOK_ASSERT_SILENT(index >= 0 && static_cast<std::size_t>(index) < _wsList.size());
helpers::sendTextFrame(getWsAt(index)->getWebSocket(), msg, getTestname());
SocketPoll::wakeupWorld();
}
/// Connect to a local test document (not a fake wopi URL), without loading it.
/// Returns the document URL to use for loading.
std::string connectToLocalDocument(const std::string& docFilename)
{
std::string documentPath, documentURL;
helpers::getDocumentPathAndURL(docFilename, documentPath, documentURL, getTestname());
LOG_TST("Connecting to local document [" << docFilename << "] with URL: " << documentURL);
_wsList.emplace_back(
std::make_unique<UnitWebSocket>(socketPoll(), documentURL, getTestname()));
return documentURL;
}
/// Connect and load a local test document (not a fake wopi document).
void connectAndLoadLocalDocument(const std::string& docFilename)
{
const std::string documentURL = connectToLocalDocument(docFilename);
LOG_TST("Loading local document [" << docFilename << "] with URL: " << documentURL);
WSD_CMD("load url=" + documentURL);
}
private:
/// The WOPISrc URL.
std::string _wopiSrc;
/// Websockets to communicate.
std::vector<std::unique_ptr<UnitWebSocket>> _wsList;
};
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */