http

tests/RenderCadenceCompositorAppConfigProviderTests.cpp

@@ -0,0 +1,124 @@
+#include "AppConfigProvider.h"
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+namespace
+{
+int gFailures = 0;
+
+void Expect(bool condition, const std::string& message)
+{
+	if (condition)
+		return;
+
+	++gFailures;
+	std::cerr << "FAILED: " << message << "\n";
+}
+
+std::filesystem::path WriteConfigFixture()
+{
+	const std::filesystem::path path = std::filesystem::temp_directory_path() / "render-cadence-compositor-config-test.json";
+	std::ofstream output(path, std::ios::binary);
+	output
+		<< "{\n"
+		<< "  \"shaderLibrary\": \"test-shaders\",\n"
+		<< "  \"serverPort\": 8181,\n"
+		<< "  \"oscBindAddress\": \"127.0.0.1\",\n"
+		<< "  \"oscPort\": 9100,\n"
+		<< "  \"oscSmoothing\": 0.25,\n"
+		<< "  \"inputVideoFormat\": \"720p\",\n"
+		<< "  \"inputFrameRate\": \"50\",\n"
+		<< "  \"outputVideoFormat\": \"2160p\",\n"
+		<< "  \"outputFrameRate\": \"60\",\n"
+		<< "  \"autoReload\": false,\n"
+		<< "  \"maxTemporalHistoryFrames\": 8,\n"
+		<< "  \"previewFps\": 24,\n"
+		<< "  \"enableExternalKeying\": true\n"
+		<< "}\n";
+	return path;
+}
+
+void TestLoadsRuntimeHostConfig()
+{
+	using namespace RenderCadenceCompositor;
+
+	const std::filesystem::path path = WriteConfigFixture();
+	AppConfigProvider provider;
+	std::string error;
+	const bool loaded = provider.Load(path, error);
+	const AppConfig& config = provider.Config();
+
+	Expect(loaded, "config loads");
+	Expect(error.empty(), "config load has no error");
+	Expect(provider.LoadedFromFile(), "provider records file load");
+	Expect(config.shaderLibrary == "test-shaders", "shader library loads");
+	Expect(config.http.preferredPort == 8181, "server port loads");
+	Expect(config.oscBindAddress == "127.0.0.1", "OSC bind address loads");
+	Expect(config.oscPort == 9100, "OSC port loads");
+	Expect(config.oscSmoothing == 0.25, "OSC smoothing loads");
+	Expect(config.inputVideoFormat == "720p", "input format loads");
+	Expect(config.inputFrameRate == "50", "input frame rate loads");
+	Expect(config.outputVideoFormat == "2160p", "output format loads");
+	Expect(config.outputFrameRate == "60", "output frame rate loads");
+	Expect(!config.autoReload, "auto reload loads");
+	Expect(config.maxTemporalHistoryFrames == 8, "history length loads");
+	Expect(config.previewFps == 24.0, "preview fps loads");
+	Expect(config.deckLink.externalKeyingEnabled, "external keying loads");
+
+	std::filesystem::remove(path);
+}
+
+void TestCommandLineOverrides()
+{
+	using namespace RenderCadenceCompositor;
+
+	AppConfigProvider provider;
+	const char* argv[] = {
+		"app.exe",
+		"--shader",
+		"solid-color",
+		"--port",
+		"8282"
+	};
+	provider.ApplyCommandLine(5, const_cast<char**>(argv));
+
+	const AppConfig& config = provider.Config();
+	Expect(config.runtimeShaderId == "solid-color", "shader CLI override applies");
+	Expect(config.http.preferredPort == 8282, "port CLI override applies");
+}
+
+void TestHelpers()
+{
+	using namespace RenderCadenceCompositor;
+
+	unsigned width = 0;
+	unsigned height = 0;
+	VideoFormatDimensions("720p", width, height);
+	Expect(width == 1280 && height == 720, "720p dimensions resolve");
+
+	VideoFormatDimensions("2160p", width, height);
+	Expect(width == 3840 && height == 2160, "2160p dimensions resolve");
+
+	const double duration = FrameDurationMillisecondsFromRateString("50");
+	Expect(duration > 19.9 && duration < 20.1, "frame duration parses numeric rate");
+}
+}
+
+int main()
+{
+	TestLoadsRuntimeHostConfig();
+	TestCommandLineOverrides();
+	TestHelpers();
+
+	if (gFailures != 0)
+	{
+		std::cerr << gFailures << " RenderCadenceCompositorAppConfigProvider test failure(s).\n";
+		return 1;
+	}
+
+	std::cout << "RenderCadenceCompositorAppConfigProvider tests passed.\n";
+	return 0;
+}

tests/RenderCadenceCompositorHttpControlServerTests.cpp

@@ -0,0 +1,110 @@
+#include "HttpControlServer.h"
+
+#include <iostream>
+#include <string>
+
+namespace
+{
+int gFailures = 0;
+
+void Expect(bool condition, const std::string& message)
+{
+	if (condition)
+		return;
+
+	++gFailures;
+	std::cerr << "FAILED: " << message << "\n";
+}
+
+void ExpectEquals(const std::string& actual, const std::string& expected, const std::string& message)
+{
+	if (actual == expected)
+		return;
+
+	++gFailures;
+	std::cerr << "FAILED: " << message << "\n"
+		<< "expected: " << expected << "\n"
+		<< "actual:   " << actual << "\n";
+}
+
+void TestParsesHttpRequest()
+{
+	using namespace RenderCadenceCompositor;
+
+	HttpControlServer::HttpRequest request;
+	const bool parsed = HttpControlServer::ParseHttpRequest(
+		"GET /api/state?cacheBust=1 HTTP/1.1\r\nHost: 127.0.0.1\r\n\r\n",
+		request);
+
+	Expect(parsed, "request parses");
+	ExpectEquals(request.method, "GET", "method is parsed");
+	ExpectEquals(request.path, "/api/state", "query string is stripped from path");
+	ExpectEquals(request.headers["host"], "127.0.0.1", "headers are lower-cased and trimmed");
+}
+
+void TestStateEndpointUsesCallback()
+{
+	using namespace RenderCadenceCompositor;
+
+	HttpControlServer server;
+	HttpControlServerCallbacks callbacks;
+	callbacks.getStateJson = []() { return std::string("{\"ok\":true}"); };
+	server.SetCallbacksForTest(callbacks);
+
+	HttpControlServer::HttpRequest request;
+	request.method = "GET";
+	request.path = "/api/state";
+
+	const HttpControlServer::HttpResponse response = server.RouteRequestForTest(request);
+	ExpectEquals(response.status, "200 OK", "state endpoint succeeds");
+	ExpectEquals(response.contentType, "application/json", "state endpoint is JSON");
+	ExpectEquals(response.body, "{\"ok\":true}", "state endpoint returns callback JSON");
+}
+
+void TestKnownPostEndpointReturnsActionError()
+{
+	using namespace RenderCadenceCompositor;
+
+	HttpControlServer server;
+	HttpControlServer::HttpRequest request;
+	request.method = "POST";
+	request.path = "/api/layers/add";
+	request.body = "{\"shaderId\":\"happy-accident\"}";
+
+	const HttpControlServer::HttpResponse response = server.RouteRequestForTest(request);
+	ExpectEquals(response.status, "400 Bad Request", "unimplemented post returns OpenAPI action error status");
+	ExpectEquals(response.contentType, "application/json", "unimplemented post returns JSON");
+	Expect(response.body.find("\"ok\":false") != std::string::npos, "unimplemented post reports ok false");
+	Expect(response.body.find("not implemented") != std::string::npos, "unimplemented post reports diagnostic");
+}
+
+void TestUnknownEndpointReturns404()
+{
+	using namespace RenderCadenceCompositor;
+
+	HttpControlServer server;
+	HttpControlServer::HttpRequest request;
+	request.method = "GET";
+	request.path = "/api/nope";
+
+	const HttpControlServer::HttpResponse response = server.RouteRequestForTest(request);
+	ExpectEquals(response.status, "404 Not Found", "unknown endpoint returns 404");
+}
+}
+
+int main()
+{
+	TestParsesHttpRequest();
+	TestStateEndpointUsesCallback();
+	TestKnownPostEndpointReturnsActionError();
+	TestUnknownEndpointReturns404();
+
+	if (gFailures != 0)
+	{
+		std::cerr << gFailures << " RenderCadenceCompositorHttpControlServer test failure(s).\n";
+		return 1;
+	}
+
+	std::cout << "RenderCadenceCompositorHttpControlServer tests passed.\n";
+	return 0;
+}