Tests

Author: Dave Plummer

tests/tests.cpp

@@ -432,3 +432,126 @@ TEST_F(APITest, RapidCreationDeletion)
         }
     }
 }
+
+TEST_F(APITest, CanvasFeatureEffectWithSchedule)
+{
+    // Create a canvas
+    json canvasData = {
+        {"id", -1},
+        {"name", "Test Canvas " + std::to_string(std::time(nullptr))},
+        {"width", 100},
+        {"height", 100}
+    };
+
+    auto createCanvasResponse = cpr::Post(
+        cpr::Url{BASE_URL + "/canvases"},
+        cpr::Body{canvasData.dump()},
+        jsonHeader, noPersistParam
+    );
+    ASSERT_EQ(createCanvasResponse.status_code, 201);
+    auto canvasJson = json::parse(createCanvasResponse.text);
+    int canvasId = canvasJson["id"].get<int>();
+
+    // Create a feature
+    json featureData = {
+        {"hostName", "test-host"},
+        {"friendlyName", "Test Feature"},
+        {"port", 1234},
+        {"width", 32},
+        {"height", 16},
+        {"offsetX", 10},
+        {"offsetY", 10},
+        {"reversed", false},
+        {"channel", 1},
+        {"redGreenSwap", false},
+        {"clientBufferCount", 8}
+    };
+
+    auto createFeatureResponse = cpr::Post(
+        cpr::Url{BASE_URL + "/canvases/" + std::to_string(canvasId) + "/features"},
+        cpr::Body{featureData.dump()},
+        jsonHeader, noPersistParam
+    );
+    ASSERT_EQ(createFeatureResponse.status_code, 200);
+    auto featureJson = json::parse(createFeatureResponse.text);
+    int featureId = featureJson["id"].get<int>();
+
+    // Create first effect with schedule
+    json effect1Data = {
+        {"type", "SolidColorFill"},
+        {"name", "Test Effect 1"},
+        {"color", {
+            {"red", 255},
+            {"green", 0},
+            {"blue", 0}
+        }},
+        {"schedule", {
+            {"daysOfWeek", 0x3E},  // Monday through Friday
+            {"startTime", "09:00:00"},
+            {"stopTime", "17:00:00"}
+        }}
+    };
+
+    auto createEffect1Response = cpr::Post(
+        cpr::Url{BASE_URL + "/canvases/" + std::to_string(canvasId) + "/effects"},
+        cpr::Body{effect1Data.dump()},
+        jsonHeader, noPersistParam
+    );
+    ASSERT_EQ(createEffect1Response.status_code, 200);
+
+    // Create second effect
+    json effect2Data = {
+        {"type", "SolidColorFill"},
+        {"name", "Test Effect 2"},
+        {"color", {
+            {"red", 0},
+            {"green", 0},
+            {"blue", 255}
+        }}
+    };
+
+    auto createEffect2Response = cpr::Post(
+        cpr::Url{BASE_URL + "/canvases/" + std::to_string(canvasId) + "/effects"},
+        cpr::Body{effect2Data.dump()},
+        jsonHeader, noPersistParam
+    );
+    ASSERT_EQ(createEffect2Response.status_code, 200);
+
+    // Get the canvas to verify effects
+    auto getCanvasResponse = cpr::Get(
+        cpr::Url{BASE_URL + "/canvases/" + std::to_string(canvasId)},
+        noPersistParam
+    );
+    ASSERT_EQ(getCanvasResponse.status_code, 200);
+    auto canvasWithEffects = json::parse(getCanvasResponse.text);
+    
+    // Verify effects through effectsManager
+    ASSERT_TRUE(canvasWithEffects.contains("effectsManager"));
+    const auto& effectsManager = canvasWithEffects["effectsManager"];
+    ASSERT_TRUE(effectsManager.contains("effects"));
+    const auto& effects = effectsManager["effects"];
+    ASSERT_EQ(effects.size(), (size_t) 2);  // We should at least have 2 effects
+
+    // For now, just verify the basic structure until we fix the deserialization
+    for (const auto& effect : effects) {
+        ASSERT_TRUE(effect.contains("type"));
+        ASSERT_TRUE(effect.contains("name"));
+        ASSERT_TRUE(effect.contains("color"));
+        ASSERT_TRUE(effect["color"].contains("r"));
+        ASSERT_TRUE(effect["color"].contains("g"));
+        ASSERT_TRUE(effect["color"].contains("b"));
+    }
+
+    // Clean up
+    auto deleteFeatureResponse = cpr::Delete(
+        cpr::Url{BASE_URL + "/canvases/" + std::to_string(canvasId) + "/features/" + std::to_string(featureId)},
+        noPersistParam
+    );
+    ASSERT_EQ(deleteFeatureResponse.status_code, 200);
+
+    auto deleteCanvasResponse = cpr::Delete(
+        cpr::Url{BASE_URL + "/canvases/" + std::to_string(canvasId)},
+        noPersistParam
+    );
+    ASSERT_EQ(deleteCanvasResponse.status_code, 200);
+}

webserver.h

@@ -296,6 +296,36 @@ class WebServer
                     }
                 });
 
+        // Add effect to canvas
+        CROW_ROUTE(_crowApp, "/api/canvases/<int>/effects")
+            .methods(crow::HTTPMethod::POST)([&](const crow::request& req, int canvasId) -> crow::response
+            {
+                try 
+                {
+                    auto reqJson = nlohmann::json::parse(req.body);
+                    auto effect = reqJson.get<shared_ptr<ILEDEffect>>();
+
+                    unique_lock writeLock(_apiMutex);
+                    auto canvas = _controller.GetCanvasById(canvasId);
+                    
+                    // Get current effects
+                    auto& effectsManager = canvas->Effects();
+                    
+                    // Add the new effect
+                    effectsManager.AddEffect(effect);
+                    
+                    PersistController(req);
+                    writeLock.unlock();
+
+                    return crow::response(crow::OK);
+                } 
+                catch (const exception& e) 
+                {
+                    logger->error("Error adding effect to canvas {}: {}", canvasId, e.what());
+                    return crow::response(crow::BAD_REQUEST, string("Error: ") + e.what());
+                }
+            });
+
         // Start the server
         _crowApp.port(_controller.GetPort()).multithreaded().run();
     }