Add Config singleton which allows to change the delays.

Setting all delays to zero significantly speeds up test times.

Add Config singleton which allows to change the delays.
Setting all delays to zero significantly speeds up test times.
Jojo-1000 · Moritz Wirger
1 parent 654ab503
Showing 21 changed files with 216 additions and 179 deletions
include/hueplusplus/Hue.h
include/hueplusplus/HueCommandAPI.h
include/hueplusplus/HueConfig.h
include/hueplusplus/IHttpHandler.h
include/hueplusplus/LinHttpHandler.h
include/hueplusplus/WinHttpHandler.h
src/ExtendedColorHueStrategy.cpp
src/ExtendedColorTemperatureStrategy.cpp
src/Hue.cpp
src/HueCommandAPI.cpp
src/LinHttpHandler.cpp
src/SimpleColorHueStrategy.cpp
src/SimpleColorTemperatureStrategy.cpp
src/UPnP.cpp
src/WinHttpHandler.cpp
test/mocks/mock_BaseHttpHandler.h
test/mocks/mock_HttpHandler.h
test/test_Hue.cpp
test/test_HueLight.cpp
test/test_Main.cpp
@@ -360,7 +360,6 @@ private:
     std::shared_ptr<const IHttpHandler> http_handler; //!< A IHttpHandler that is used to communicate with the
                                                       //!< bridge
-    std::chrono::steady_clock::duration refreshDuration;
     std::shared_ptr<APICache> stateCache;
     ResourceList<HueLight, int> lights;
@@ -135,9 +135,6 @@ private:
     //! \returns "/api/<username>/<path>"
     std::string CombinedPath(const std::string& path) const;
-public:
-    static constexpr std::chrono::steady_clock::duration minDelay = std::chrono::milliseconds(100);
-
 private:
     std::string ip;
     int port;
@@ -23,10 +23,53 @@
 #ifndef INCLUDE_HUEPLUSPLUS_HUE_CONFIG_H
 #define INCLUDE_HUEPLUSPLUS_HUE_CONFIG_H
+#include <chrono>
+
 namespace hueplusplus
 {
-constexpr uint16_t c_PRE_ALERT_DELAY = 120; //!< Delay for advanced alerts before the actual alert
-constexpr uint16_t c_POST_ALERT_DELAY = 1600; //!< Delay for advanced alerts after the actual alert
+//! \brief Configurable delays
+//!
+//! Used to set all delays to zero when running tests.
+class Config
+{
+private:
+    using duration = std::chrono::steady_clock::duration;
+
+public:
+    //! \brief Delay for advanced alerts before the actual alert
+    duration getPreAlertDelay() const { return preAlertDelay; }
+    //! \brief Delay for advanced alerts after the actual alert
+    duration getPostAlertDelay() const { return postAlertDelay; }
+
+    //! \brief Timeout for UPnP multicast request
+    duration getUPnPTimeout() const { return upnpTimeout; }
+
+    //! \brief Delay between bridge requests
+    duration getBridgeRequestDelay() const { return bridgeRequestDelay; }
+
+    //! \brief Timeout for Hue::requestUsername, waits until link button was pressed
+    duration getRequestUsernameTimeout() const { return requestUsernameDelay; }
+
+    //! \brief Interval in which username requests are attempted
+    duration getRequestUsernameAttemptInterval() const { return requestUsernameAttemptInterval; }
+
+    //! \brief Get config instance
+    static Config& instance()
+    {
+        static Config c;
+        return c;
+    }
+protected:
+    Config() = default;
+
+protected:
+    duration preAlertDelay = std::chrono::milliseconds(120);
+    duration postAlertDelay = std::chrono::milliseconds(1600);
+    duration upnpTimeout = std::chrono::seconds(5);
+    duration bridgeRequestDelay = std::chrono::milliseconds(100);
+    duration requestUsernameDelay = std::chrono::seconds(35);
+    duration requestUsernameAttemptInterval = std::chrono::seconds(1);
+};
 } // namespace hueplusplus
 #endif
@@ -23,6 +23,7 @@
 #ifndef INCLUDE_HUEPLUSPLUS_IHTTPHANDLER_H
 #define INCLUDE_HUEPLUSPLUS_IHTTPHANDLER_H
+#include <chrono>
 #include <iostream>
 #include <memory>
 #include <string>
@@ -63,14 +64,14 @@ public:
     //! \param msg The message that should sent to the specified multicast address
     //! \param adr Optional ip or hostname in dotted decimal notation, default is "239.255.255.250"
     //! \param port Optional port the request is sent to, default is 1900
-    //! \param timeout Optional time to wait for responses in seconds, default is 5
+    //! \param timeout Optional time to wait for responses, default is 5 seconds
     //!
     //! Blocks for the duration of the timeout.
     //!
     //! \return vector of strings containing each received answer
     //! \throws std::system_error when system or socket operations fail
-    virtual std::vector<std::string> sendMulticast(
-        const std::string& msg, const std::string& adr = "239.255.255.250", int port = 1900, int timeout = 5) const = 0;
+    virtual std::vector<std::string> sendMulticast(const std::string& msg, const std::string& adr = "239.255.255.250",
+        int port = 1900, std::chrono::steady_clock::duration timeout = std::chrono::seconds(5)) const = 0;
     //! \brief Send a HTTP request with the given method to the specified host and return the body of the response.
     //!
@@ -52,11 +52,11 @@ public:
     //! address \param adr Optional String that contains an ip or hostname in
     //! dotted decimal notation, default is "239.255.255.250" \param port Optional
     //! integer that specifies the port to which the request is sent. Default is
-    //! 1900 \param timeout Optional Integer that specifies the timeout of the
-    //! request in seconds. Default is 5 \return Vector containing strings of each
+    //! 1900 \param timeout Optional The timeout of the
+    //! request. Default is 5 seconds \return Vector containing strings of each
     //! answer received
-    virtual std::vector<std::string> sendMulticast(
-        const std::string& msg, const std::string& adr = "239.255.255.250", int port = 1900, int timeout = 5) const;
+    std::vector<std::string> sendMulticast(const std::string& msg, const std::string& adr = "239.255.255.250",
+        int port = 1900, std::chrono::steady_clock::duration timeout = std::chrono::seconds(5)) const override;
 };
 } // namespace hueplusplus
@@ -58,11 +58,11 @@ public:
     //! address \param adr Optional String that contains an ip or hostname in
     //! dotted decimal notation, default is "239.255.255.250" \param port Optional
     //! integer that specifies the port to which the request is sent. Default is
-    //! 1900 \param timeout Optional Integer that specifies the timeout of the
-    //! request in seconds. Default is 5 \return Vector containing strings of each
+    //! 1900 \param timeout Optional The timeout of the
+    //! request. Default is 5 seconds \return Vector containing strings of each
     //! answer received
     std::vector<std::string> sendMulticast(const std::string& msg, const std::string& adr = "239.255.255.250",
-        int port = 1900, int timeout = 5) const override;
+        int port = 1900, std::chrono::steady_clock::duration timeout = std::chrono::seconds(5)) const override;
 private:
     WSADATA wsaData;
@@ -44,12 +44,12 @@ bool ExtendedColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, Hue
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorHueSaturation(oldHue, oldSat, 1);
@@ -68,12 +68,12 @@ bool ExtendedColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, Hue
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorXY(oldX, oldY, 1);
@@ -91,12 +91,12 @@ bool ExtendedColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, Hue
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorTemperature(oldCT, 1);
@@ -127,12 +127,12 @@ bool ExtendedColorHueStrategy::alertXY(float x, float y, HueLight&amp; light) const
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorHueSaturation(oldHue, oldSat, 1);
@@ -151,12 +151,12 @@ bool ExtendedColorHueStrategy::alertXY(float x, float y, HueLight&amp; light) const
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorXY(oldX, oldY, 1);
@@ -174,12 +174,12 @@ bool ExtendedColorHueStrategy::alertXY(float x, float y, HueLight&amp; light) const
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorTemperature(oldCT, 1);
@@ -210,12 +210,12 @@ bool ExtendedColorHueStrategy::alertRGB(uint8_t r, uint8_t g, uint8_t b, HueLigh
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorHueSaturation(oldHue, oldSat, 1);
@@ -234,12 +234,12 @@ bool ExtendedColorHueStrategy::alertRGB(uint8_t r, uint8_t g, uint8_t b, HueLigh
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorXY(oldX, oldY, 1);
@@ -257,12 +257,12 @@ bool ExtendedColorHueStrategy::alertRGB(uint8_t r, uint8_t g, uint8_t b, HueLigh
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorTemperature(oldCT, 1);
@@ -85,12 +85,12 @@ bool ExtendedColorTemperatureStrategy::alertTemperature(unsigned int mired, HueL
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorHueSaturation(oldHue, oldSat, 1);
@@ -109,12 +109,12 @@ bool ExtendedColorTemperatureStrategy::alertTemperature(unsigned int mired, HueL
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorXY(oldX, oldY, 1);
@@ -132,12 +132,12 @@ bool ExtendedColorTemperatureStrategy::alertTemperature(unsigned int mired, HueL
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorTemperature(oldCT, 1);
@@ -31,6 +31,7 @@
 #include <stdexcept>
 #include <thread>
+#include "hueplusplus/HueConfig.h"
 #include "hueplusplus/HueExceptionMacro.h"
 #include "hueplusplus/UPnP.h"
 #include "hueplusplus/Utils.h"
@@ -160,51 +161,44 @@ int Hue::getBridgePort() const
 std::string Hue::requestUsername()
 {
-    std::cout << "Please press the link Button! You've got 35 secs!\n"; // when the link
-                                                                        // button was
-                                                                        // pressed we
-                                                                        // got 30
-                                                                        // seconds to
-                                                                        // get our
-                                                                        // username for
-                                                                        // control
+    std::chrono::steady_clock::duration timeout = Config::instance().getRequestUsernameTimeout();
+    std::chrono::steady_clock::duration checkInterval = Config::instance().getRequestUsernameAttemptInterval();
+    std::cout << "Please press the link Button! You've got "
+              << std::chrono::duration_cast<std::chrono::seconds>(timeout).count() << " secs!\n";
+    // when the link button was pressed we got 30 seconds to get our username for control
     nlohmann::json request;
     request["devicetype"] = "HuePlusPlus#User";
     nlohmann::json answer;
     std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
-    std::chrono::steady_clock::time_point lastCheck;
-    while (std::chrono::steady_clock::now() - start < std::chrono::seconds(35))
+    // do-while loop to check at least once when timeout is 0
+    do
     {
-        if (std::chrono::steady_clock::now() - lastCheck > std::chrono::seconds(1))
+        std::this_thread::sleep_for(checkInterval);
+        answer = http_handler->POSTJson("/api", request, ip, port);
+        nlohmann::json jsonUser = utils::safeGetMember(answer, 0, "success", "username");
+        if (jsonUser != nullptr)
         {
-            lastCheck = std::chrono::steady_clock::now();
-            answer = http_handler->POSTJson("/api", request, ip, port);
-            nlohmann::json jsonUser = utils::safeGetMember(answer, 0, "success", "username");
-            if (jsonUser != nullptr)
-            {
-                // [{"success":{"username": "<username>"}}]
-                username = jsonUser.get<std::string>();
-                // Update commands with new username and ip
-                setHttpHandler(http_handler);
-                std::cout << "Success! Link button was pressed!\n";
-                std::cout << "Username is \"" << username << "\"\n";
-                break;
-            }
-            else if (answer.size() > 0 && answer[0].count("error"))
+            // [{"success":{"username": "<username>"}}]
+            username = jsonUser.get<std::string>();
+            // Update commands with new username and ip
+            setHttpHandler(http_handler);
+            std::cout << "Success! Link button was pressed!\n";
+            std::cout << "Username is \"" << username << "\"\n";
+            break;
+        }
+        else if (answer.size() > 0 && answer[0].count("error"))
+        {
+            HueAPIResponseException exception = HueAPIResponseException::Create(CURRENT_FILE_INFO, answer[0]);
+            // All errors except 101: Link button not pressed
+            if (exception.GetErrorNumber() != 101)
             {
-                HueAPIResponseException exception = HueAPIResponseException::Create(CURRENT_FILE_INFO, answer[0]);
-                // All errors except 101: Link button not pressed
-                if (exception.GetErrorNumber() != 101)
-                {
-                    throw exception;
-                }
+                throw exception;
             }
-
-            std::this_thread::sleep_until(lastCheck + std::chrono::seconds(1));
         }
-    }
+    } while (std::chrono::steady_clock::now() - start < timeout);
+
     return username;
 }
@@ -425,9 +419,10 @@ std::string Hue::getPictureOfModel(const std::string&amp; model_id) const
 void Hue::setHttpHandler(std::shared_ptr<const IHttpHandler> handler)
 {
     http_handler = handler;
-    stateCache = std::make_shared<APICache>("", HueCommandAPI(ip, port, username, handler), refreshDuration);
+    stateCache
+        = std::make_shared<APICache>("", HueCommandAPI(ip, port, username, handler), stateCache->getRefreshDuration());
     lights = ResourceList<HueLight, int>("/lights", stateCache, "lights",
-        [factory = HueLightFactory(stateCache->getCommandAPI(), refreshDuration)](
+        [factory = HueLightFactory(stateCache->getCommandAPI(), stateCache->getRefreshDuration())](
             int id, const nlohmann::json& state) mutable { return factory.createLight(state, id); });
     groups = CreateableResourceList<Group, int, CreateGroup>("/groups", stateCache, "groups");
     schedules = CreateableResourceList<Schedule, int, CreateSchedule>("/schedules", stateCache, "schedules");
@@ -24,12 +24,11 @@
 #include <thread>
+#include "hueplusplus/HueConfig.h"
 #include "hueplusplus/HueExceptionMacro.h"
 namespace hueplusplus
 {
-constexpr std::chrono::steady_clock::duration HueCommandAPI::minDelay;
-
 namespace
 {
 // Runs functor with appropriate timeout and retries when timed out or connection reset
@@ -81,7 +80,7 @@ nlohmann::json HueCommandAPI::PUTRequest(const std::string&amp; path, const nlohmann
 nlohmann::json HueCommandAPI::PUTRequest(
     const std::string& path, const nlohmann::json& request, FileInfo fileInfo) const
 {
-    return HandleError(std::move(fileInfo), RunWithTimeout(timeout, minDelay, [&]() {
+    return HandleError(std::move(fileInfo), RunWithTimeout(timeout, Config::instance().getBridgeRequestDelay(), [&]() {
         return httpHandler->PUTJson(CombinedPath(path), request, ip, port);
     }));
 }
@@ -94,7 +93,7 @@ nlohmann::json HueCommandAPI::GETRequest(const std::string&amp; path, const nlohmann
 nlohmann::json HueCommandAPI::GETRequest(
     const std::string& path, const nlohmann::json& request, FileInfo fileInfo) const
 {
-    return HandleError(std::move(fileInfo), RunWithTimeout(timeout, minDelay, [&]() {
+    return HandleError(std::move(fileInfo), RunWithTimeout(timeout, Config::instance().getBridgeRequestDelay(), [&]() {
         return httpHandler->GETJson(CombinedPath(path), request, ip, port);
     }));
 }
@@ -107,7 +106,7 @@ nlohmann::json HueCommandAPI::DELETERequest(const std::string&amp; path, const nlohm
 nlohmann::json HueCommandAPI::DELETERequest(
     const std::string& path, const nlohmann::json& request, FileInfo fileInfo) const
 {
-    return HandleError(std::move(fileInfo), RunWithTimeout(timeout, minDelay, [&]() {
+    return HandleError(std::move(fileInfo), RunWithTimeout(timeout, Config::instance().getBridgeRequestDelay(), [&]() {
         return httpHandler->DELETEJson(CombinedPath(path), request, ip, port);
     }));
 }
@@ -120,7 +119,7 @@ nlohmann::json HueCommandAPI::POSTRequest(const std::string&amp; path, const nlohman
 nlohmann::json HueCommandAPI::POSTRequest(
     const std::string& path, const nlohmann::json& request, FileInfo fileInfo) const
 {
-    return HandleError(std::move(fileInfo), RunWithTimeout(timeout, minDelay, [&]() {
+    return HandleError(std::move(fileInfo), RunWithTimeout(timeout, Config::instance().getBridgeRequestDelay(), [&]() {
         return httpHandler->POSTJson(CombinedPath(path), request, ip, port);
     }));
 }
@@ -139,7 +139,7 @@ std::string LinHttpHandler::send(const std::string&amp; msg, const std::string&amp; adr,
 }
 std::vector<std::string> LinHttpHandler::sendMulticast(
-    const std::string& msg, const std::string& adr, int port, int timeout) const
+    const std::string& msg, const std::string& adr, int port, std::chrono::steady_clock::duration timeout) const
 {
     hostent* server; // host information
     sockaddr_in server_addr; // server address
@@ -187,7 +187,7 @@ std::vector&lt;std::string&gt; LinHttpHandler::sendMulticast(
     char buffer[2048] = {}; // receive buffer
     std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
-    while (std::chrono::steady_clock::now() - start < std::chrono::seconds(timeout))
+    while (std::chrono::steady_clock::now() - start < timeout)
     {
         ssize_t bytesReceived = recv(socketFD, &buffer, 2048, MSG_DONTWAIT);
         if (bytesReceived < 0)
@@ -97,12 +97,12 @@ bool SimpleColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, HueLi
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorHueSaturation(oldHue, oldSat, 1);
@@ -121,12 +121,12 @@ bool SimpleColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, HueLi
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorXY(oldX, oldY, 1);
@@ -157,12 +157,12 @@ bool SimpleColorHueStrategy::alertXY(float x, float y, HueLight&amp; light) const
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorHueSaturation(oldHue, oldSat, 1);
@@ -181,12 +181,12 @@ bool SimpleColorHueStrategy::alertXY(float x, float y, HueLight&amp; light) const
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorXY(oldX, oldY, 1);
@@ -217,12 +217,12 @@ bool SimpleColorHueStrategy::alertRGB(uint8_t r, uint8_t g, uint8_t b, HueLight&amp;
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorHueSaturation(oldHue, oldSat, 1);
@@ -241,12 +241,12 @@ bool SimpleColorHueStrategy::alertRGB(uint8_t r, uint8_t g, uint8_t b, HueLight&amp;
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorXY(oldX, oldY, 1);
@@ -50,12 +50,12 @@ bool SimpleColorTemperatureStrategy::alertTemperature(unsigned int mired, HueLig
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_PRE_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPreAlertDelay());
         if (!light.alert())
         {
             return false;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(c_POST_ALERT_DELAY));
+        std::this_thread::sleep_for(Config::instance().getPostAlertDelay());
         if (!on)
         {
             light.setColorTemperature(oldCT, 1);
@@ -25,6 +25,8 @@
 #include <algorithm>
 #include <iostream>
+#include "hueplusplus/HueConfig.h"
+
 namespace hueplusplus
 {
 std::vector<std::pair<std::string, std::string>> UPnP::getDevices(std::shared_ptr<const IHttpHandler> handler)
@@ -33,7 +35,7 @@ std::vector&lt;std::pair&lt;std::string, std::string&gt;&gt; UPnP::getDevices(std::shared_pt
     std::vector<std::string> foundDevices
         = handler->sendMulticast("M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\nMAN: "
                                  "\"ssdp:discover\"\r\nMX: 5\r\nST: ssdp:all\r\n\r\n",
-            "239.255.255.250", 1900, 5);
+            "239.255.255.250", 1900, Config::instance().getUPnPTimeout());
     std::vector<std::pair<std::string, std::string>> devices;
@@ -41,9 +43,19 @@ std::vector&lt;std::pair&lt;std::string, std::string&gt;&gt; UPnP::getDevices(std::shared_pt
     for (const std::string& s : foundDevices)
     {
         std::pair<std::string, std::string> device;
-        int start = s.find("LOCATION:") + 10;
+        std::size_t start = s.find("LOCATION:");
+        if (start == std::string::npos)
+        {
+            continue;
+        }
+        start += 10;
         device.first = s.substr(start, s.find("\r\n", start) - start);
-        start = s.find("SERVER:") + 8;
+        start = s.find("SERVER:");
+        if (start == std::string::npos)
+        {
+            continue;
+        }
+        start += 8;
         device.second = s.substr(start, s.find("\r\n", start) - start);
         if (std::find_if(devices.begin(), devices.end(),
                 [&](const std::pair<std::string, std::string>& item) { return item.first == device.first; })
@@ -174,7 +174,7 @@ std::string WinHttpHandler::send(const std::string&amp; msg, const std::string&amp; adr,
 }
 std::vector<std::string> WinHttpHandler::sendMulticast(
-    const std::string& msg, const std::string& adr, int port, int timeout) const
+    const std::string& msg, const std::string& adr, int port, std::chrono::steady_clock::duration timeout) const
 {
     struct addrinfo hints = {};
     hints.ai_family = AF_INET;
@@ -262,7 +262,7 @@ std::vector&lt;std::string&gt; WinHttpHandler::sendMulticast(
     const int recvbuflen = 2048;
     char recvbuf[recvbuflen] = {};
     std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
-    while (std::chrono::steady_clock::now() - start < std::chrono::seconds(timeout))
+    while (std::chrono::steady_clock::now() - start < timeout)
     {
         int res = recv(connect_socket, recvbuf, recvbuflen, 0);
         if (res > 0)
@@ -38,7 +38,7 @@ public:
     MOCK_CONST_METHOD3(send, std::string(const std::string& msg, const std::string& adr, int port));
     MOCK_CONST_METHOD4(
-        sendMulticast, std::vector<std::string>(const std::string& msg, const std::string& adr, int port, int timeout));
+        sendMulticast, std::vector<std::string>(const std::string& msg, const std::string& adr, int port, std::chrono::steady_clock::duration timeout));
 };
 #endif
@@ -39,8 +39,9 @@ public:
     MOCK_CONST_METHOD3(sendGetHTTPBody, std::string(const std::string& msg, const std::string& adr, int port));
-    MOCK_CONST_METHOD4(
-        sendMulticast, std::vector<std::string>(const std::string& msg, const std::string& adr, int port, int timeout));
+    MOCK_CONST_METHOD4(sendMulticast,
+        std::vector<std::string>(
+            const std::string& msg, const std::string& adr, int port, std::chrono::steady_clock::duration timeout));
     MOCK_CONST_METHOD6(sendHTTPRequest,
         std::string(const std::string& method, const std::string& uri, const std::string& content_type,
@@ -29,6 +29,7 @@
 #include "testhelper.h"
 #include "hueplusplus/Hue.h"
+#include "hueplusplus/HueConfig.h"
 #include "json/json.hpp"
 #include "mocks/mock_HttpHandler.h"
@@ -47,7 +48,7 @@ protected:
         EXPECT_CALL(*handler,
             sendMulticast("M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\nMAN: "
                           "\"ssdp:discover\"\r\nMX: 5\r\nST: ssdp:all\r\n\r\n",
-                "239.255.255.250", 1900, 5))
+                "239.255.255.250", 1900, Config::instance().getUPnPTimeout()))
             .Times(AtLeast(1))
             .WillRepeatedly(Return(getMulticastReply()));
@@ -42,73 +42,35 @@ protected:
 protected:
     HueLightTest()
         : handler(std::make_shared<MockHttpHandler>()),
+          hue_bridge_state({{"lights",
+              {{"1",
+                   {{"state",
+                        {{"on", true}, {"bri", 254}, {"ct", 366}, {"alert", "none"}, {"colormode", "ct"},
+                            {"reachable", true}, {"effect", "none"}}},
+                       {"swupdate", {{"state", "noupdates"}, {"lastinstall", nullptr}}}, {"type", "Dimmable light"},
+                       {"name", "Hue lamp 1"}, {"modelid", "LWB004"}, {"manufacturername", "Philips"},
+                       {"productname", "Hue bloom"}, {"uniqueid", "00:00:00:00:00:00:00:00-00"},
+                       {"swversion", "5.50.1.19085"}, {"luminaireuniqueid", "0000000"}}},
+                  {"2",
+                      {{"state",
+                           {{"on", false}, {"bri", 0}, {"ct", 366}, {"hue", 12345}, {"sat", 123},
+                               {"xy", {0.102, 0.102}}, {"alert", "none"}, {"colormode", "ct"}, {"reachable", true},
+                               {"effect", "none"}}},
+                          {"swupdate", {{"state", "noupdates"}, {"lastinstall", nullptr}}}, {"type", "Color light"},
+                          {"name", "Hue lamp 2"}, {"modelid", "LST001"}, {"uniqueid", "11:11:11:11:11:11:11:11-11"},
+                          {"swversion", "5.50.1.19085"}}},
+                  {"3",
+                      {{"state",
+                           {{"on", false}, {"bri", 254}, {"ct", 366}, {"hue", 12345}, {"sat", 123},
+                               {"xy", {0.102, 0.102}}, {"alert", "none"}, {"colormode", "ct"}, {"reachable", true},
+                               {"effect", "none"}}},
+                          {"swupdate", {{"state", "noupdates"}, {"lastinstall", nullptr}}},
+                          {"type", "Extended color light"}, {"name", "Hue lamp 3"}, {"modelid", "LCT010"},
+                          {"manufacturername", "Philips"}, {"productname", "Hue bloom"},
+                          {"swversion", "5.50.1.19085"}}}}}}),
           test_bridge(getBridgeIp(), getBridgePort(), getBridgeUsername(), handler)
     {
         using namespace ::testing;
-        hue_bridge_state["lights"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["1"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["1"]["state"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["1"]["state"]["on"] = true;
-        hue_bridge_state["lights"]["1"]["state"]["bri"] = 254;
-        hue_bridge_state["lights"]["1"]["state"]["ct"] = 366;
-        hue_bridge_state["lights"]["1"]["state"]["alert"] = "none";
-        hue_bridge_state["lights"]["1"]["state"]["colormode"] = "ct";
-        hue_bridge_state["lights"]["1"]["state"]["reachable"] = true;
-        hue_bridge_state["lights"]["1"]["state"]["effect"] = "none";
-        hue_bridge_state["lights"]["1"]["swupdate"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["1"]["swupdate"]["state"] = "noupdates";
-        hue_bridge_state["lights"]["1"]["swupdate"]["lastinstall"] = nullptr;
-        hue_bridge_state["lights"]["1"]["type"] = "Dimmable light";
-        hue_bridge_state["lights"]["1"]["name"] = "Hue lamp 1";
-        hue_bridge_state["lights"]["1"]["modelid"] = "LWB004";
-        hue_bridge_state["lights"]["1"]["manufacturername"] = "Philips";
-        hue_bridge_state["lights"]["1"]["productname"] = "Hue bloom";
-        hue_bridge_state["lights"]["1"]["uniqueid"] = "00:00:00:00:00:00:00:00-00";
-        hue_bridge_state["lights"]["1"]["swversion"] = "5.50.1.19085";
-        hue_bridge_state["lights"]["1"]["luminaireuniqueid"] = "0000000";
-        hue_bridge_state["lights"]["2"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["2"]["state"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["2"]["state"]["on"] = false;
-        hue_bridge_state["lights"]["2"]["state"]["bri"] = 0;
-        hue_bridge_state["lights"]["2"]["state"]["ct"] = 366;
-        hue_bridge_state["lights"]["2"]["state"]["hue"] = 123456;
-        hue_bridge_state["lights"]["2"]["state"]["sat"] = 123;
-        hue_bridge_state["lights"]["2"]["state"]["xy"][0] = 0.102;
-        hue_bridge_state["lights"]["2"]["state"]["xy"][1] = 0.102;
-        hue_bridge_state["lights"]["2"]["state"]["alert"] = "none";
-        hue_bridge_state["lights"]["2"]["state"]["colormode"] = "ct";
-        hue_bridge_state["lights"]["2"]["state"]["reachable"] = true;
-        hue_bridge_state["lights"]["2"]["state"]["effect"] = "none";
-        hue_bridge_state["lights"]["2"]["swupdate"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["2"]["swupdate"]["state"] = "noupdates";
-        hue_bridge_state["lights"]["2"]["swupdate"]["lastinstall"] = nullptr;
-        hue_bridge_state["lights"]["2"]["type"] = "Color light";
-        hue_bridge_state["lights"]["2"]["name"] = "Hue lamp 2";
-        hue_bridge_state["lights"]["2"]["modelid"] = "LST001";
-        hue_bridge_state["lights"]["2"]["uniqueid"] = "11:11:11:11:11:11:11:11-11";
-        hue_bridge_state["lights"]["2"]["swversion"] = "5.50.1.19085";
-        hue_bridge_state["lights"]["3"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["3"]["state"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["3"]["state"]["on"] = false;
-        hue_bridge_state["lights"]["3"]["state"]["bri"] = 254;
-        hue_bridge_state["lights"]["3"]["state"]["ct"] = 366;
-        hue_bridge_state["lights"]["3"]["state"]["hue"] = 123456;
-        hue_bridge_state["lights"]["3"]["state"]["sat"] = 123;
-        hue_bridge_state["lights"]["3"]["state"]["xy"][0] = 0.102;
-        hue_bridge_state["lights"]["3"]["state"]["xy"][1] = 0.102;
-        hue_bridge_state["lights"]["3"]["state"]["alert"] = "none";
-        hue_bridge_state["lights"]["3"]["state"]["colormode"] = "ct";
-        hue_bridge_state["lights"]["3"]["state"]["reachable"] = true;
-        hue_bridge_state["lights"]["3"]["state"]["effect"] = "none";
-        hue_bridge_state["lights"]["3"]["swupdate"] = nlohmann::json::object();
-        hue_bridge_state["lights"]["3"]["swupdate"]["state"] = "noupdates";
-        hue_bridge_state["lights"]["3"]["swupdate"]["lastinstall"] = nullptr;
-        hue_bridge_state["lights"]["3"]["type"] = "Extended color light";
-        hue_bridge_state["lights"]["3"]["name"] = "Hue lamp 3";
-        hue_bridge_state["lights"]["3"]["modelid"] = "LCT010";
-        hue_bridge_state["lights"]["3"]["manufacturername"] = "Philips";
-        hue_bridge_state["lights"]["3"]["productname"] = "Hue bloom";
-        hue_bridge_state["lights"]["3"]["swversion"] = "5.50.1.19085";
         EXPECT_CALL(*handler, GETJson("/api/" + getBridgeUsername(), nlohmann::json::object(), getBridgeIp(), 80))
             .Times(AtLeast(1))
@@ -126,7 +88,7 @@ protected:
             .Times(AtLeast(1))
             .WillRepeatedly(Return(hue_bridge_state["lights"]["3"]));
     }
-    ~HueLightTest(){};
+    ~HueLightTest() {};
 };
 TEST_F(HueLightTest, Constructor)
@@ -692,15 +654,15 @@ TEST_F(HueLightTest, getColorHueSaturation)
     HueLight test_light_3 = test_bridge.getLight(3);
     EXPECT_EQ(std::make_pair(static_cast<uint16_t>(0), static_cast<uint8_t>(0)), ctest_light_1.getColorHueSaturation());
-    EXPECT_EQ(std::make_pair(static_cast<uint16_t>(123456), static_cast<uint8_t>(123)),
-        ctest_light_2.getColorHueSaturation());
-    EXPECT_EQ(std::make_pair(static_cast<uint16_t>(123456), static_cast<uint8_t>(123)),
-        ctest_light_3.getColorHueSaturation());
+    EXPECT_EQ(
+        std::make_pair(static_cast<uint16_t>(12345), static_cast<uint8_t>(123)), ctest_light_2.getColorHueSaturation());
+    EXPECT_EQ(
+        std::make_pair(static_cast<uint16_t>(12345), static_cast<uint8_t>(123)), ctest_light_3.getColorHueSaturation());
     EXPECT_EQ(std::make_pair(static_cast<uint16_t>(0), static_cast<uint8_t>(0)), test_light_1.getColorHueSaturation());
     EXPECT_EQ(
-        std::make_pair(static_cast<uint16_t>(123456), static_cast<uint8_t>(123)), test_light_2.getColorHueSaturation());
+        std::make_pair(static_cast<uint16_t>(12345), static_cast<uint8_t>(123)), test_light_2.getColorHueSaturation());
     EXPECT_EQ(
-        std::make_pair(static_cast<uint16_t>(123456), static_cast<uint8_t>(123)), test_light_3.getColorHueSaturation());
+        std::make_pair(static_cast<uint16_t>(12345), static_cast<uint8_t>(123)), test_light_3.getColorHueSaturation());
 }
 TEST_F(HueLightTest, setColorXY)
@@ -21,9 +21,35 @@
 **/
 #include <gtest/gtest.h>
+#include <hueplusplus/HueConfig.h>
+
+namespace
+{
+class TestConfig : public hueplusplus::Config
+{
+public:
+    TestConfig()
+    {
+        preAlertDelay = postAlertDelay = upnpTimeout = bridgeRequestDelay = requestUsernameDelay
+            = requestUsernameAttemptInterval = std::chrono::seconds(0);
+    }
+};
+
+// Environment sets config to disable all delays and speed up tests
+class Environment : public ::testing::Environment
+{
+public:
+    ~Environment() override {}
+
+    void SetUp() override { hueplusplus::Config::instance() = TestConfig(); }
+
+    void TearDown() override {}
+};
+} // namespace
 int main(int argc, char** argv)
 {
     ::testing::InitGoogleTest(&argc, argv);
+    ::testing::AddGlobalTestEnvironment(new Environment());
     return RUN_ALL_TESTS();
 }
@@ -26,6 +26,7 @@
 #include "iostream"
 #include "testhelper.h"
+#include "hueplusplus/HueConfig.h"
 #include "hueplusplus/UPnP.h"
 #include "json/json.hpp"
 #include "mocks/mock_HttpHandler.h"
@@ -42,7 +43,7 @@ TEST(UPnP, getDevices)
     EXPECT_CALL(*handler,
         sendMulticast("M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\nMAN: "
                       "\"ssdp:discover\"\r\nMX: 5\r\nST: ssdp:all\r\n\r\n",
-            "239.255.255.250", 1900, 5))
+            "239.255.255.250", 1900, Config::instance().getUPnPTimeout()))
         .Times(1)
         .WillRepeatedly(::testing::Return(getMulticastReply()));