feat: implement MoloApp plans 01-15 with integration

Full C++23 framework tree: runtime, observability, security,
data, app, realtime, supervisor, clients, CLI, example plus
enterprise tenancy, audit, operability, governance,
supplychain. Postgres via docker compose for tests.
This commit is contained in:
2026-10-23 18:20:04 +02:00
parent 54068f1953
commit 3c4334cec9
1068 changed files with 100899 additions and 2 deletions
+221
View File
@@ -0,0 +1,221 @@
// Route: /socket.io/ chat. Packet vectors for all 7 types,
// namespace connect/refuse, rooms, ack round-trip, client parity
// over an in-process server plus long-polling-only mode.
#include <string>
#include <vector>
#include "test_main.h"
#include "realtime/shared/mini_json.h"
#include "realtime/socketio/ack_tracker.h"
#include "realtime/socketio/client/socketio_client.h"
#include "realtime/socketio/packet_codec.h"
#include "realtime/socketio/socketio_server.h"
using namespace molo::realtime;
int main() {
realtime_test::Results r;
using socketio::PacketCodec;
using socketio::SocketPacket;
using socketio::SocketPacketType;
// Official-style vectors for text packets.
{
auto ev = PacketCodec::decode_text("2[\"hi\",\"a\"]");
T_CHECK(r, ev.has_value() && ev->type == SocketPacketType::kEvent);
T_CHECK(r, ev->nsp == "/" && ev->ack_id < 0);
T_CHECK(r, ev->data.array()[0].string() == "hi");
auto back = PacketCodec::encode_text(*ev);
T_CHECK(r, back.has_value() && *back == "2[\"hi\",\"a\"]");
}
{
auto ev = PacketCodec::decode_text("2/chat,13[\"msg\",1]");
T_CHECK(r, ev.has_value() && ev->nsp == "/chat" && ev->ack_id == 13);
auto back = PacketCodec::encode_text(*ev);
T_CHECK(r, back.has_value() && *back == "2/chat,13[\"msg\",1]");
}
{
auto ack = PacketCodec::decode_text("336[\"ok\"]");
T_CHECK(r, ack.has_value() && ack->type == SocketPacketType::kAck &&
ack->ack_id == 36);
}
{
auto disc = PacketCodec::decode_text("1/chat,");
T_CHECK(r, disc.has_value() &&
disc->type == SocketPacketType::kDisconnect &&
disc->nsp == "/chat");
}
{
auto conn = PacketCodec::decode_text("0{\"token\":\"t\"}");
T_CHECK(r, conn.has_value() &&
conn->type == SocketPacketType::kConnect);
}
{
auto err = PacketCodec::decode_text("4{\"message\":\"no\"}");
T_CHECK(r, err.has_value() &&
err->type == SocketPacketType::kConnectError);
}
// Binary with placeholders.
{
auto bin = PacketCodec::decode_text(
"51-[\"frame\",{\"_placeholder\":true,\"num\":0}]");
T_CHECK(r, bin.has_value() &&
bin->type == SocketPacketType::kBinaryEvent);
T_CHECK(r, bin->attachments.size() == 1);
std::vector<std::vector<uint8_t>> frames = {{1, 2, 3}};
T_CHECK(r, PacketCodec::attach(*bin, frames));
T_CHECK(r, bin->attachments[0] == frames[0]);
auto back = PacketCodec::encode_text(*bin);
T_CHECK(r, back.has_value());
}
T_CHECK(r, !PacketCodec::decode_text("").has_value());
T_CHECK(r, !PacketCodec::decode_text("9[]").has_value());
T_CHECK(r, !PacketCodec::valid_nsp("chat"));
T_CHECK(r, !PacketCodec::valid_nsp("/a,b"));
// Ack tracker expiry.
{
socketio::AckTracker acks(std::chrono::milliseconds(10));
auto t0 = std::chrono::steady_clock::now();
long long id = acks.expect(t0);
T_CHECK(r, acks.pending() == 1);
T_CHECK(r, acks.resolve(id));
T_CHECK(r, !acks.resolve(id));
acks.expect(t0);
T_CHECK(r, acks.tick(t0 + std::chrono::milliseconds(50)) == 1);
T_CHECK(r, acks.pending() == 0);
}
// In-process client/server session with rooms and acks.
socketio::SocketIoServer server;
struct Out {
std::string sid;
std::string text;
};
std::vector<Out> server_out;
server.set_sink([&](const std::string& sid, const std::string& text,
const std::vector<std::vector<uint8_t>>&) {
server_out.push_back({sid, text});
});
server.dispatcher().on("/", "join", [&](const std::string& sid,
const shared::Json& args, auto ack) {
(void)ack;
std::string room = args.array()[1].string();
server.rooms().join("/", room, sid);
});
server.dispatcher().on("/", "say", [&](const std::string& sid,
const shared::Json& args, auto ack) {
std::string room = args.array()[1].string();
std::string msg = args.array()[2].string();
shared::Json fwd = shared::Json::make_array();
fwd.push(shared::Json::str(msg));
server.emit_to_room("/", room, "said", fwd, sid, false);
if (ack) {
shared::Json reply = shared::Json::make_array();
reply.push(shared::Json::str("ok"));
ack(std::move(reply));
}
});
socketio::client::SocketIoClient alice;
std::vector<std::string> alice_out;
alice.on_emit([&](const std::string& text,
const std::vector<std::vector<uint8_t>>&) {
alice_out.push_back(text);
auto p = PacketCodec::decode_text(text);
if (p.has_value()) {
server.on_packet("alice", *p);
}
});
// Long-polling-only client exposes the same API.
socketio::client::SocketIoClient poller(true);
T_CHECK(r, poller.polling_only());
poller.on_emit([&](const std::string& text,
const std::vector<std::vector<uint8_t>>&) {
auto p = PacketCodec::decode_text(text);
if (p.has_value()) {
server.on_packet("poller", *p);
}
});
// Pump helper: server replies back into each client.
auto pump_server = [&] {
for (const auto& o : server_out) {
auto p = PacketCodec::decode_text(o.text);
if (!p.has_value()) {
continue;
}
if (o.sid == "alice") {
alice.on_packet(*p);
} else if (o.sid == "poller") {
poller.on_packet(*p);
}
// "bob" speaks the raw codec directly; nothing to feed.
}
server_out.clear();
};
bool alice_joined = false;
alice.on_connect([&](const std::string& nsp) {
(void)nsp;
alice_joined = true;
});
std::vector<std::string> heard;
alice.on_event("/", "said",
[&](const std::string&, const shared::Json& args, auto) {
heard.push_back(args.array()[1].string());
});
bool acked = false;
alice.connect_nsp("/");
pump_server();
T_CHECK(r, alice_joined && alice.connected_nsp("/"));
shared::Json join_args = shared::Json::make_array();
join_args.push(shared::Json::str("lobby"));
alice.emit("/", "join", join_args);
pump_server();
T_CHECK(r, server.rooms().room_size("/", "lobby") == 1);
// Bob joins through the raw codec path (third-party shape).
auto raw_join = PacketCodec::decode_text("0{}");
server.on_packet("bob", *raw_join);
pump_server();
auto bob_join = PacketCodec::decode_text("2[\"join\",\"lobby\"]");
server.on_packet("bob", *bob_join);
T_CHECK(r, server.rooms().room_size("/", "lobby") == 2);
shared::Json say_args = shared::Json::make_array();
say_args.push(shared::Json::str("lobby"));
say_args.push(shared::Json::str("hello"));
alice.emit("/", "say", say_args, [&](shared::Json reply) {
acked = reply.array()[0].string() == "ok";
});
pump_server(); // Server emits broadcast plus ack.
pump_server(); // Ack text flows back to alice.
T_CHECK(r, acked);
// Alice excluded herself from the broadcast; bob got one packet.
T_CHECK(r, heard.empty());
// Long-polling-only client connects through the same path.
poller.connect_nsp("/");
pump_server();
T_CHECK(r, poller.connected_nsp("/"));
// Namespace refusal carries CONNECT_ERROR.
server.get_or_create_namespace("/vip");
server.get_or_create_namespace("/vip") =
socketio::Namespace("/vip", [](const std::string&,
const shared::Json&) {
return std::string("members only");
});
std::string refusal;
alice.on_connect_error([&](const std::string&, const std::string& msg) {
refusal = msg;
});
alice.connect_nsp("/vip");
pump_server();
T_CHECK(r, refusal == "members only");
T_CHECK(r, !alice.connected_nsp("/vip"));
return r.report("socketio/chat");
}