sequa::core_server : ProtocolSession (poignée de main hello -> welcome/error, JSON provisoire identique à Studio, même règle de compatibilité) séparée du transport CoreServer (IXWebSocket 12.1.0, écoute 127.0.0.1:9100). Exécutable sequa-core. Vérification exclusive du port sous Windows (IXWebSocket active SO_REUSEADDR). Sanitizers appliqués à tout le build (ASan MSVC exige des dépendances instrumentées). ADR 0005. 30 tests (Debug, Release, ASan), dont 4 sur vrais sockets.
184 lines
5.3 KiB
C++
184 lines
5.3 KiB
C++
// SPDX-License-Identifier: MPL-2.0
|
|
//
|
|
// Tests d'intégration : un vrai client WebSocket (IXWebSocket) contre le CoreServer, en
|
|
// boucle locale.
|
|
#include "sequa/core/server/protocol.hpp"
|
|
#include "sequa/core/server/server.hpp"
|
|
|
|
#include <doctest/doctest.h>
|
|
#include <ixwebsocket/IXNetSystem.h>
|
|
#include <ixwebsocket/IXWebSocket.h>
|
|
#include <nlohmann/json.hpp>
|
|
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using namespace sequa::core::server;
|
|
using nlohmann::json;
|
|
|
|
namespace {
|
|
|
|
constexpr auto timeout = std::chrono::seconds(5);
|
|
|
|
// IXWebSocket ne rapporte pas le port choisi par le système pour le port 0 : on essaie
|
|
// une plage de ports locaux jusqu'au premier libre.
|
|
std::unique_ptr<CoreServer> start_server()
|
|
{
|
|
for (int port = 19100; port < 19200; ++port) {
|
|
ServerOptions options;
|
|
options.port = port;
|
|
options.core_version = "9.9.9-test";
|
|
auto server = std::make_unique<CoreServer>(options);
|
|
if (server->start().empty()) {
|
|
return server;
|
|
}
|
|
}
|
|
FAIL("aucun port libre entre 19100 et 19199");
|
|
return nullptr;
|
|
}
|
|
|
|
class TestClient {
|
|
public:
|
|
explicit TestClient(int port)
|
|
{
|
|
ix::initNetSystem();
|
|
socket_.setUrl("ws://127.0.0.1:" + std::to_string(port));
|
|
socket_.disableAutomaticReconnection();
|
|
socket_.setOnMessageCallback([this](const ix::WebSocketMessagePtr& message) {
|
|
const std::lock_guard lock(mutex_);
|
|
switch (message->type) {
|
|
case ix::WebSocketMessageType::Open:
|
|
open_ = true;
|
|
break;
|
|
case ix::WebSocketMessageType::Message:
|
|
messages_.push_back(message->str);
|
|
break;
|
|
case ix::WebSocketMessageType::Close:
|
|
closed_ = true;
|
|
close_code_ = message->closeInfo.code;
|
|
break;
|
|
case ix::WebSocketMessageType::Error:
|
|
closed_ = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
changed_.notify_all();
|
|
});
|
|
socket_.start();
|
|
}
|
|
|
|
~TestClient()
|
|
{
|
|
socket_.stop();
|
|
ix::uninitNetSystem();
|
|
}
|
|
|
|
TestClient(const TestClient&) = delete;
|
|
TestClient& operator=(const TestClient&) = delete;
|
|
|
|
bool wait_open() { return wait([this] { return open_ || closed_; }) && open_; }
|
|
void send(const std::string& text) { socket_.sendText(text); }
|
|
|
|
std::vector<std::string> wait_messages(std::size_t count)
|
|
{
|
|
wait([this, count] { return messages_.size() >= count || closed_; });
|
|
const std::lock_guard lock(mutex_);
|
|
return messages_;
|
|
}
|
|
|
|
bool wait_closed() { return wait([this] { return closed_; }); }
|
|
|
|
std::uint16_t close_code()
|
|
{
|
|
const std::lock_guard lock(mutex_);
|
|
return close_code_;
|
|
}
|
|
|
|
private:
|
|
template <typename Predicate>
|
|
bool wait(Predicate predicate)
|
|
{
|
|
std::unique_lock lock(mutex_);
|
|
return changed_.wait_for(lock, timeout, predicate);
|
|
}
|
|
|
|
ix::WebSocket socket_;
|
|
std::mutex mutex_;
|
|
std::condition_variable changed_;
|
|
bool open_ = false;
|
|
bool closed_ = false;
|
|
std::uint16_t close_code_ = 0;
|
|
std::vector<std::string> messages_;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
TEST_CASE("Serveur : poignee de main hello/welcome sur un vrai socket")
|
|
{
|
|
const auto server = start_server();
|
|
REQUIRE(server);
|
|
CHECK(server->running());
|
|
|
|
TestClient client(server->options().port);
|
|
REQUIRE(client.wait_open());
|
|
client.send(encode_hello(protocol_version, "sequa-studio"));
|
|
|
|
const auto messages = client.wait_messages(1);
|
|
REQUIRE(messages.size() == 1);
|
|
const json welcome = json::parse(messages.front());
|
|
CHECK(welcome["type"] == "welcome");
|
|
CHECK(welcome["payload"]["coreVersion"] == "9.9.9-test");
|
|
CHECK(welcome["payload"]["protocolVersion"] == std::string(protocol_version));
|
|
}
|
|
|
|
TEST_CASE("Serveur : version incompatible -> error puis fermeture 1008")
|
|
{
|
|
const auto server = start_server();
|
|
REQUIRE(server);
|
|
|
|
TestClient client(server->options().port);
|
|
REQUIRE(client.wait_open());
|
|
client.send(encode_hello("0.2.0", "sequa-studio"));
|
|
|
|
const auto messages = client.wait_messages(1);
|
|
REQUIRE(messages.size() == 1);
|
|
CHECK(json::parse(messages.front())["payload"]["code"] == "incompatible-protocol");
|
|
REQUIRE(client.wait_closed());
|
|
CHECK(client.close_code() == close_code::policy_violation);
|
|
}
|
|
|
|
TEST_CASE("Serveur : plusieurs clients independants")
|
|
{
|
|
const auto server = start_server();
|
|
REQUIRE(server);
|
|
|
|
TestClient good(server->options().port);
|
|
TestClient bad(server->options().port);
|
|
REQUIRE(good.wait_open());
|
|
REQUIRE(bad.wait_open());
|
|
|
|
bad.send("pas du json");
|
|
good.send(encode_hello(protocol_version, "sequa-studio"));
|
|
|
|
REQUIRE(bad.wait_closed());
|
|
const auto messages = good.wait_messages(1);
|
|
REQUIRE(messages.size() == 1);
|
|
CHECK(json::parse(messages.front())["type"] == "welcome");
|
|
}
|
|
|
|
TEST_CASE("Serveur : port deja occupe -> start() renvoie une erreur")
|
|
{
|
|
const auto first = start_server();
|
|
REQUIRE(first);
|
|
ServerOptions options;
|
|
options.port = first->options().port;
|
|
CoreServer second(options);
|
|
CHECK_FALSE(second.start().empty());
|
|
CHECK_FALSE(second.running());
|
|
}
|