Merge pull request #1 from thoughtworks-hpc/add-unit-test

Add unit test

Author: canmor

rest/configuration.h

@@ -6,6 +6,8 @@
 
 #include "generator.h"
 
+#include <unordered_map>
+
 constexpr auto DR_EVILS_DARK_ENERGY_ENERGY_SUPPLIER = "Dr Evil's Dark Energy";
 constexpr auto THE_GREEN_ECO_ENERGY_SUPPLIER = "The Green Eco";
 constexpr auto POWER_FOR_EVERYONE_ENERGY_SUPPLIER = "Power for Everyone";

rest/controller/MeterReadingController.h

@@ -64,6 +64,9 @@ class MeterReadingController {
     auto body = nlohmann::json::parse(req.body());
     auto smartMeterId = body["smartMeterId"];
     std::vector<ElectricityReading> electricityReadings;
+    if (!IsMeterReadingsValid(smartMeterId, body["electricityReadings"])) {
+      return {http::status::internal_server_error, 11};
+    }
     for (auto &electricityReading : body["electricityReadings"]) {
       electricityReadings.emplace_back(detail::fromRfc3339(electricityReading["time"]), electricityReading["reading"]);
     }
@@ -74,6 +77,13 @@ class MeterReadingController {
  private:
   ElectricityReadingService &electricityReadingService;
   MeterReadingService &meterReadingService;
+  bool IsMeterReadingsValid(const nlohmann::basic_json<> &smartMeterId,
+                            const nlohmann::basic_json<> &electricityReadings) {
+    if (smartMeterId.type() == nlohmann::json::value_t::null || electricityReadings.empty()) {
+      return false;
+    }
+    return true;
+  }
 };
 
 #endif  // DEVELOPER_JOYOFENERGY_CPP_BEAST_METERREADINGCONTROLLER_H

rest/controller/PricePlanComparatorController.h

@@ -31,9 +31,10 @@ class PricePlanComparatorController {
     res.set(http::field::content_type, "application/json");
     res.keep_alive(req.keep_alive());
     nlohmann::json j;
-    j["pricePlanComparisons"] = {{"price-plan-0", double(costs.value()["price-plan-0"]) / 10000},
-                                 {"price-plan-1", double(costs.value()["price-plan-1"]) / 10000},
-                                 {"price-plan-2", double(costs.value()["price-plan-2"]) / 10000}};
+    for (auto &ele : costs.value()) {
+      ele.second /= 10000;
+    }
+    j["pricePlanComparisons"] = costs.value();
     j["pricePlanId"] = current_price_plans[meterId];
     res.body() = j.dump();
     res.prepare_payload();
@@ -43,17 +44,22 @@ class PricePlanComparatorController {
   http::response<http::string_body> Recommend(const http::request<http::string_body> &req,
                                               const std::vector<std::string> &queries) {
     const auto &meterId = queries[0];
-    int limit = std::stoi(queries[2]);
+    std::optional<int> maybeLimit;
+    if (queries.size() > 2){
+      maybeLimit = std::stoi(queries[2]);
+    }
     auto costs = pricePlanService.getConsumptionCostOfElectricityReadingsForEachPricePlan(meterId);
 
     if (!costs) {
       return {http::status::not_found, req.version()};
     }
 
-    std::vector<std::pair<std::string, float>> ordered_costs{costs->begin(), costs->end()};
+    std::vector<std::pair<std::string, double>> ordered_costs{costs->begin(), costs->end()};
     std::sort(ordered_costs.begin(), ordered_costs.end(),
               [](auto &cost_a, auto &cost_b) { return cost_a.second < cost_b.second; });
-    ordered_costs.resize(std::min(limit, int(ordered_costs.size())));
+    if (maybeLimit.has_value()) {
+      ordered_costs.resize(std::min(maybeLimit.value(), int(ordered_costs.size())));
+    }
 
     http::response<http::string_body> res{http::status::ok, req.version()};
     res.set(http::field::content_type, "application/json");

rest/domain/ElectricityReading.h

@@ -14,6 +14,9 @@ class ElectricityReading {
 
   size_t getReading() const { return reading; }
 
+  bool operator==(const ElectricityReading& rhs) const { return time == rhs.time && reading == rhs.reading; }
+  bool operator!=(const ElectricityReading& rhs) const { return !(rhs == *this); }
+
  private:
   time_point_type time;
   size_t reading;

rest/domain/PricePlan.h

@@ -2,32 +2,52 @@
 #define DEVELOPER_JOYOFENERGY_CPP_BEAST_PRICEPLAN_H
 
 #include <string>
+#include <utility>
 #include <vector>
 
 class PricePlan {
   // todo:
  public:
+  using time_point_type = std::chrono::time_point<std::chrono::system_clock>;
   class PeakTimeMultiplier {
+   public:
     enum DayOfWeek {
+      SUNDAY,
       MONDAY,
       TUESDAY,
+      WEDNESDAY,
+      THURSDAY,
+      FRIDAY,
+      SATURDAY
     };
 
+    PeakTimeMultiplier(DayOfWeek dayOfWeek, int multiplier) : dayOfWeek(dayOfWeek), multiplier(multiplier) {}
+
     DayOfWeek dayOfWeek;
     int multiplier;
-
-    PeakTimeMultiplier(DayOfWeek dayOfWeek, int multiplier) : dayOfWeek(dayOfWeek), multiplier(multiplier) {}
   };
 
   PricePlan(std::string planName, std::string energySupplier, int unitRate, std::vector<PeakTimeMultiplier> peakTimeMultipliers)
-      : planName(planName), energySupplier(energySupplier), unitRate(unitRate), peakTimeMultipliers(peakTimeMultipliers) {}
+      : planName(std::move(planName)), energySupplier(std::move(energySupplier)), unitRate(unitRate), peakTimeMultipliers(std::move(peakTimeMultipliers)) {}
 
   std::string getEnergySupplier() const { return energySupplier; }
 
   std::string getPlanName() const { return planName; }
 
   int getUnitRate() const { return unitRate; }
 
+  int getPrice(time_point_type dateTime) const {
+    auto time_t_dateTime = std::chrono::system_clock::to_time_t(dateTime);
+    auto t = std::localtime(&time_t_dateTime);
+    auto it = std::find_if(peakTimeMultipliers.begin(), peakTimeMultipliers.end(), [=](auto &p) {
+      return p.dayOfWeek == t->tm_wday;
+    });
+    if (it == peakTimeMultipliers.end()) {
+      return unitRate;
+    }
+    return unitRate * it->multiplier;
+  }
+
  private:
   const std::string energySupplier;
   const std::string planName;

rest/service/MeterReadingService.h

@@ -9,6 +9,7 @@
 
 #include <iostream>
 #include <map>
+#include <unordered_map>
 #include <optional>
 #include <string>
 #include <vector>

rest/service/PricePlanService.h

@@ -2,7 +2,6 @@
 #define DEVELOPER_JOYOFENERGY_CPP_BEAST_PRICEPLANSERVICE_H
 
 #include <configuration.h>
-#include <controller/MeterReadingController.h>
 #include <domain/ElectricityReading.h>
 #include <domain/PricePlan.h>
 #include <service/MeterReadingService.h>

test/CMakeLists.txt

@@ -4,4 +4,19 @@ find_package(GTest REQUIRED)
 find_package(nlohmann_json REQUIRED)
 target_link_libraries(endpoint_test PRIVATE GTest::gmock_main nlohmann_json::nlohmann_json rest)
 
-add_test(endpoint_test endpoint_test)
+add_executable(controller_test)
+target_sources(controller_test PRIVATE controller/MeterReadingControllerTest.cpp controller/PricePlanComparatorControllerTest.cpp)
+target_link_libraries(controller_test PRIVATE GTest::gmock_main nlohmann_json::nlohmann_json rest)
+
+add_executable(domain_test)
+target_sources(domain_test PRIVATE domain/PricePlanTest.cpp)
+target_link_libraries(domain_test PRIVATE GTest::gmock_main rest)
+
+add_executable(service_test)
+target_sources(service_test PRIVATE service/MeterReadingServiceTest.cpp)
+target_link_libraries(service_test PRIVATE GTest::gmock_main rest)
+
+add_test(endpoint_test endpoint_test)
+add_test(controller_test controller_test)
+add_test(domain_test domain_test)
+add_test(service_test service_test)

test/ReadingTest.cpp

@@ -1,6 +1,5 @@
 #include <nlohmann/json.hpp>
 
-#include "domain/ElectricityReading.h"
 #include "generator.h"
 #include "test/EndpointTest.h"
 

test/controller/MeterReadingControllerTest.cpp

@@ -0,0 +1,136 @@
+#include <gmock/gmock.h>
+#include <rest/controller/MeterReadingController.h>
+
+#include <boost/beast/http.hpp>
+#include <nlohmann/json.hpp>
+
+using nlohmann::json;
+using ::testing::Eq;
+
+namespace http = boost::beast::http;
+
+class MeterReadingControllerTest : public ::testing::Test {
+ protected:
+  std::unordered_map<std::string, std::vector<ElectricityReading>> meterAssociatedReadings;
+  ElectricityReadingService electricityReadingService{meterAssociatedReadings};
+  MeterReadingService meterReadingService{meterAssociatedReadings};
+  MeterReadingController controller{electricityReadingService, meterReadingService};
+
+  http::request<http::string_body> BuildRequest(http::verb verb, boost::string_view target, const json &request_body) {
+    http::request<http::string_body> req{verb, target, 11};
+    req.set(http::field::content_type, "application/json");
+    req.body() = request_body.dump();
+    req.prepare_payload();
+    return req;
+  }
+};
+
+TEST_F(MeterReadingControllerTest, StoreShouldResponseWithErrorGivenNoMeterIdIsSupplied) {
+  auto req = BuildRequest(http::verb::post, "/readings/store", R"({})"_json);
+  std::vector<std::string> queries;
+
+  auto response = controller.Store(req, queries);
+
+  EXPECT_THAT(response.result(), Eq(http::status::internal_server_error));
+}
+
+TEST_F(MeterReadingControllerTest, StoreShouldResponseWithErrorGivenEmptyMeterReading) {
+  json body = R"({
+            "smartMeterId": "smart-meter-0",
+            "electricityReadings": []
+    })"_json;
+  auto req = BuildRequest(http::verb::post, "/readings/store", body);
+  std::vector<std::string> queries;
+
+  auto response = controller.Store(req, queries);
+
+  EXPECT_THAT(response.result(), Eq(http::status::internal_server_error));
+}
+
+TEST_F(MeterReadingControllerTest, StoreShouldResponseWithErrorGivenNoMeterReadingIsSupplied) {
+  json body = R"({
+            "smartMeterId": "smart-meter-0"
+    })"_json;
+  auto req = BuildRequest(http::verb::post, "/readings/store", body);
+  std::vector<std::string> queries;
+
+  auto response = controller.Store(req, queries);
+
+  EXPECT_THAT(response.result(), Eq(http::status::internal_server_error));
+}
+
+TEST_F(MeterReadingControllerTest, StoreShouldStoreGivenMultipleBatchesOfMeterReadings) {
+  json body1 = R"({
+            "smartMeterId": "smart-meter-0",
+            "electricityReadings": [
+                    {
+                            "time": "2021-08-18T06:42:15.725202Z",
+                            "reading": 1
+                    }
+            ]
+    })"_json;
+  json body2 = R"({
+            "smartMeterId": "smart-meter-0",
+            "electricityReadings": [
+                    {
+                            "time": "2021-08-18T06:44:15.725202Z",
+                            "reading": 2
+                    }
+            ]
+    })"_json;
+  auto req1 = BuildRequest(http::verb::post, "/readings/store", body1);
+  auto req2 = BuildRequest(http::verb::post, "/readings/store", body2);
+  std::vector<std::string> queries;
+
+  controller.Store(req1, queries);
+  controller.Store(req2, queries);
+
+  std::vector<ElectricityReading> expectedElectricityReadings = {
+      {detail::fromRfc3339("2021-08-18T06:42:15.725202Z"), 1},
+      {detail::fromRfc3339("2021-08-18T06:44:15.725202Z"), 2}
+  };
+
+  EXPECT_THAT(meterReadingService.getReadings("smart-meter-0"), Eq(expectedElectricityReadings));
+}
+
+TEST_F(MeterReadingControllerTest, StoreShouldStoreAssociatedWithUserGivenMeterReadingsAssociatedWithTheUser) {
+  json body1 = R"({
+            "smartMeterId": "smart-meter-0",
+            "electricityReadings": [
+                    {
+                            "time": "2021-08-18T06:42:15.725202Z",
+                            "reading": 1
+                    }
+            ]
+    })"_json;
+  json body2 = R"({
+            "smartMeterId": "smart-meter-1",
+            "electricityReadings": [
+                    {
+                            "time": "2021-08-18T06:44:15.725202Z",
+                            "reading": 2
+                    }
+            ]
+    })"_json;
+  auto req1 = BuildRequest(http::verb::post, "/readings/store", body1);
+  auto req2 = BuildRequest(http::verb::post, "/readings/store", body2);
+  std::vector<std::string> queries;
+
+  controller.Store(req1, queries);
+  controller.Store(req2, queries);
+
+  std::vector<ElectricityReading> expectedElectricityReadings = {
+      {detail::fromRfc3339("2021-08-18T06:42:15.725202Z"), 1},
+  };
+
+  EXPECT_THAT(meterReadingService.getReadings("smart-meter-0"), Eq(expectedElectricityReadings));
+}
+
+TEST_F(MeterReadingControllerTest, ReadShouldReturnNotFoundGivenMeterIdThatIsNotRecognised) {
+  http::request<http::string_body> req;
+  std::vector<std::string> queries = {"smart-meter-0"};
+
+  auto response = controller.Read(req, queries);
+
+  EXPECT_THAT(response.result(), Eq(http::status::not_found));
+}