Use IEnvironment in WaterPumpScheduler to get time, instead of passing it in as a parameter.

Author: GreenWizard2015

controller/tea_poor/lib/CommandProcessor/CommandProcessor.cpp

@@ -54,7 +54,7 @@ std::string CommandProcessor::pour_tea(const char *milliseconds, const char *pow
     return std::string("{ \"error\": \"invalid power value\" }");
   }
   // start pouring tea
-  _waterPump->start( atoi(milliseconds), atoi(power), _env->time() );
+  _waterPump->start( atoi(milliseconds), atoi(power) );
   return status();
 }
 

controller/tea_poor/lib/WaterPumpScheduler/WaterPumpScheduler.cpp

@@ -1,7 +1,8 @@
 #include "WaterPumpScheduler.h"
 
-WaterPumpScheduler::WaterPumpScheduler(IWaterPumpPtr waterPump, unsigned long forceStopIntervalMs) :
+WaterPumpScheduler::WaterPumpScheduler(IWaterPumpPtr waterPump, IEnvironmentPtr env, unsigned long forceStopIntervalMs) :
   _waterPump(waterPump),
+  _env(env),
   _forceStopIntervalMs(forceStopIntervalMs)
 {
 }
@@ -12,8 +13,8 @@ void WaterPumpScheduler::setup() {
   _waterPump->setup();
 }
 
-void WaterPumpScheduler::start(unsigned long runTimeMs, int power, unsigned long currentTimeMs) {
-  _stopTime = currentTimeMs + runTimeMs;
+void WaterPumpScheduler::start(unsigned long runTimeMs, int power) {
+  _stopTime = _env->time() + runTimeMs;
   _waterPump->start(power);
 }
 
@@ -22,7 +23,8 @@ void WaterPumpScheduler::stop() {
   _stopTime = 0; // a bit of paranoia :)
 }
 
-void WaterPumpScheduler::tick(unsigned long currentTimeMs) {
+void WaterPumpScheduler::tick() {
+  const auto currentTimeMs = _env->time();
   if (_stopTime <= currentTimeMs) {
     stop();
     _stopTime = currentTimeMs + _forceStopIntervalMs; // force stop after X milliseconds

controller/tea_poor/lib/WaterPumpScheduler/WaterPumpScheduler.h

@@ -3,27 +3,30 @@
 
 #include <IWaterPump.h>
 #include <IWaterPumpSchedulerAPI.h>
+#include <IEnvironment.h>
 
 // This class is responsible for scheduling water pump
 // It is used to make sure that water pump is running for a limited time
 // It is also ensuring that water pump is stopped if not needed
 class WaterPumpScheduler : public IWaterPumpSchedulerAPI {
 private:
   IWaterPumpPtr _waterPump;
+  IEnvironmentPtr _env;
   unsigned long _stopTime = 0;
   // each X milliseconds will force stop water pump
   unsigned long _forceStopIntervalMs;
 public:
-  WaterPumpScheduler(IWaterPumpPtr waterPump, unsigned long forceStopIntervalMs);
-  WaterPumpScheduler(IWaterPumpPtr waterPump) : WaterPumpScheduler(waterPump, 1000) {}
+  WaterPumpScheduler(IWaterPumpPtr waterPump, IEnvironmentPtr env, unsigned long forceStopIntervalMs);
+  // forceStopIntervalMs is set to 1000ms by default
+  WaterPumpScheduler(IWaterPumpPtr waterPump, IEnvironmentPtr env) : WaterPumpScheduler(waterPump, env, 1000) {}
   ~WaterPumpScheduler();
 
   void setup();
   // for simplicity and testability we are passing current time as parameter
-  void tick(unsigned long currentTimeMs);
+  void tick();
 
   // Public API
-  void start(unsigned long runTimeMs, int power, unsigned long currentTimeMs) override;
+  void start(unsigned long runTimeMs, int power) override;
   void stop() override;
   WaterPumpStatus status() override;
 };

controller/tea_poor/lib/interfaces/IWaterPumpSchedulerAPI.h

@@ -22,7 +22,7 @@ class IWaterPumpSchedulerAPI {
 public:
   virtual ~IWaterPumpSchedulerAPI() {}
   virtual void stop() = 0;
-  virtual void start(unsigned long runTimeMs, int power, unsigned long currentTimeMs) = 0;
+  virtual void start(unsigned long runTimeMs, int power) = 0;
   virtual WaterPumpStatus status() = 0;
 };
 

controller/tea_poor/src/main.cpp

@@ -9,13 +9,13 @@
 #include <sstream>
 #include <ArduinoEnvironment.h>
 
-IEnvironmentPtr env = std::make_shared<ArduinoEnvironment>();
+const IEnvironmentPtr env = std::make_shared<ArduinoEnvironment>();
 
 // Setting up water pump
-auto waterPump = std::make_shared<WaterPumpScheduler>(
+const auto waterPump = std::make_shared<WaterPumpScheduler>(
   std::make_shared<WaterPumpController>(
     WATER_PUMP_DIRECTION_PIN, WATER_PUMP_BRAKE_PIN, WATER_PUMP_POWER_PIN
-  )
+  ), env
 );
 
 // build command processor
@@ -76,6 +76,6 @@ void setup() {
 }
 
 void loop() {
-  waterPump->tick(millis());
+  waterPump->tick();
   remoteControl.process();
 };

controller/tea_poor/test/test_native/tests/CommandProcessor_test.h

@@ -34,8 +34,8 @@ TEST(CommandProcessor, pour_tea_invalid_power) {
 
 // for simplicity of the UI, we should accept as valid 0 and exactly threshold value
 TEST(CommandProcessor, pour_tea_valid_boundary_values) {
-  auto env = std::make_shared<FakeEnvironment>();
-  auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>();
+  const auto env = std::make_shared<FakeEnvironment>();
+  const auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>(env);
   CommandProcessor commandProcessor(123, env, waterPump);
 
   ASSERT_NE(commandProcessor.pour_tea("0", VALID_POWER), INVALID_TIME_ERROR_MESSAGE);
@@ -44,27 +44,27 @@ TEST(CommandProcessor, pour_tea_valid_boundary_values) {
 
 // test that start pouring tea by calling pour_tea() method with specified parameters
 TEST(CommandProcessor, pour_tea) {
-  auto env = std::make_shared<FakeEnvironment>();
+  const auto env = std::make_shared<FakeEnvironment>();
+  const auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>(env);
   env->time(2343);
-  auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>();
   CommandProcessor commandProcessor(10000, env, waterPump);
   const auto response = commandProcessor.pour_tea("1234", "23");
   ASSERT_EQ(waterPump->_log, "start(1234, 23, 2343)\n");
 }
 
 // test that stop() method stops pouring tea
 TEST(CommandProcessor, stop) {
-  auto env = std::make_shared<FakeEnvironment>();
-  auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>();
+  const auto env = std::make_shared<FakeEnvironment>();
+  const auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>(env);
   CommandProcessor commandProcessor(123, env, waterPump);
   const auto response = commandProcessor.stop();
   ASSERT_EQ(waterPump->_log, "stop()\n");
 }
 
 // test that status() method returns JSON string with water pump status
 TEST(CommandProcessor, status) {
-  auto env = std::make_shared<FakeEnvironment>();
-  auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>();
+  const auto env = std::make_shared<FakeEnvironment>();
+  const auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>(env);
   CommandProcessor commandProcessor(123, env, waterPump);
   const auto response = commandProcessor.status();
   ASSERT_EQ(response, "{"
@@ -80,8 +80,8 @@ TEST(CommandProcessor, status) {
 
 // test that status() method returns JSON string with actual time left
 TEST(CommandProcessor, status_running) {
-  auto env = std::make_shared<FakeEnvironment>();
-  auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>();
+  const auto env = std::make_shared<FakeEnvironment>();
+  const auto waterPump = std::make_shared<FakeWaterPumpSchedulerAPI>(env);
   CommandProcessor commandProcessor(12345, env, waterPump);
 
   commandProcessor.pour_tea("1123", "100");

controller/tea_poor/test/test_native/tests/WaterPumpScheduler_test.h

@@ -1,61 +1,67 @@
 #include <gtest/gtest.h>
 #include "mocks/FakeWaterPump.h"
+#include "mocks/FakeEnvironment.h"
 #include <WaterPumpScheduler.h>
 
 // test that pump is stopping after given time
 TEST(WaterPumpScheduler, test_pump_stops_after_given_time) {
   // random time between 1 and 10 seconds
   const unsigned long runTimeMs = 1000 + (rand() % 10) * 1000;
+  const auto fakeEnvironment = std::make_shared<FakeEnvironment>();
   const auto fakeWaterPump = std::make_shared<FakeWaterPump>();
-  WaterPumpScheduler waterPumpScheduler(fakeWaterPump);
+  WaterPumpScheduler waterPumpScheduler(fakeWaterPump, fakeEnvironment);
   waterPumpScheduler.setup();
   // start water pump
-  unsigned long currentTimeMs = 0;
-  waterPumpScheduler.start(runTimeMs, 1, currentTimeMs);
+  fakeEnvironment->time(0);
+  waterPumpScheduler.start(runTimeMs, 1);
   ASSERT_EQ(fakeWaterPump->powerInPercents(), 1);
   // check status
   auto status = waterPumpScheduler.status();
   ASSERT_TRUE(status.isRunning);
   ASSERT_EQ(status.stopTime, runTimeMs);
 
-  while (currentTimeMs < runTimeMs) {
-    waterPumpScheduler.tick(currentTimeMs);
+  while (fakeEnvironment->time() < runTimeMs) {
+    waterPumpScheduler.tick();
     ASSERT_TRUE(fakeWaterPump->isRunning());
-    currentTimeMs += 100;
+    fakeEnvironment->time(fakeEnvironment->time() + 100);
   }
   // pump should be stopped after given time
-  waterPumpScheduler.tick(runTimeMs + 1);
+  fakeEnvironment->time(runTimeMs + 1);
+  waterPumpScheduler.tick();
   ASSERT_FALSE(fakeWaterPump->isRunning());
 }
 
 // test that pump is periodically forced to stop after given time
 TEST(WaterPumpScheduler, test_pump_is_periodically_forced_to_stop_after_given_time) {
   const auto fakeWaterPump = std::make_shared<FakeWaterPump>();
-  WaterPumpScheduler waterPumpScheduler(fakeWaterPump, 1000); // force stop each 1 second
+  const auto fakeEnvironment = std::make_shared<FakeEnvironment>();
+  const int T = 1000; // 1 second
+  WaterPumpScheduler waterPumpScheduler(fakeWaterPump, fakeEnvironment, T); // force stop each T
   waterPumpScheduler.setup();
   // start water pump
-  unsigned long currentTimeMs = 0;
-  waterPumpScheduler.start(1, 1, currentTimeMs);
-  currentTimeMs += 1;
-  waterPumpScheduler.tick(currentTimeMs);
+  fakeEnvironment->time(0);
+  waterPumpScheduler.start(1, 1);
+  fakeEnvironment->time(1);
+  waterPumpScheduler.tick();
   ASSERT_FALSE(fakeWaterPump->isRunning()); // pump should be stopped after given time
 
   for(int i = 0; i < 10; i++) {
     // emulate that pump was started again
     fakeWaterPump->start(1);
     ASSERT_EQ(fakeWaterPump->powerInPercents(), 1);
-    currentTimeMs += 1000;
-    waterPumpScheduler.tick(currentTimeMs);
+    fakeEnvironment->time(fakeEnvironment->time() + T);
+    waterPumpScheduler.tick();
     ASSERT_FALSE(fakeWaterPump->isRunning()); // pump should be stopped
   }
 }
 
 // test that pumps power is set to specified value
 TEST(WaterPumpScheduler, test_pumps_power_is_set_to_specified_value) {
   const auto fakeWaterPump = std::make_shared<FakeWaterPump>();
-  WaterPumpScheduler waterPumpScheduler(fakeWaterPump);
+  const auto fakeEnvironment = std::make_shared<FakeEnvironment>();
+  WaterPumpScheduler waterPumpScheduler(fakeWaterPump, fakeEnvironment);
   waterPumpScheduler.setup();
   const int power = 23;
-  waterPumpScheduler.start(1, power, 0);
+  waterPumpScheduler.start(1, power);
   ASSERT_EQ(fakeWaterPump->powerInPercents(), power);
 }

controller/tea_poor/test/test_native/tests/mocks/FakeWaterPumpSchedulerAPI.h

@@ -3,19 +3,24 @@
 #define FAKE_WATER_PUMP_SCHEDULER_API_H
 
 #include <IWaterPumpSchedulerAPI.h>
+#include <IEnvironment.h>
 #include <string>
 
 class FakeWaterPumpSchedulerAPI : public IWaterPumpSchedulerAPI {
+private:
+  const IEnvironmentPtr _env;
 public:
+  FakeWaterPumpSchedulerAPI(IEnvironmentPtr env) : _env(env) {}
+
   void stop() override {
     _log += "stop()\n";
   }
 
-  void start(unsigned long runTimeMs, int power, unsigned long currentTimeMs) override {
+  void start(unsigned long runTimeMs, int power) override {
     _log += "start(" + 
       std::to_string(runTimeMs) + ", " +
       std::to_string(power) + ", " +
-      std::to_string(currentTimeMs) +
+      std::to_string(_env->time()) +
       ")\n";
   }