Update variable and method names. (#36)

greenpithumb/db_store.py

@@ -24,7 +24,7 @@ def store_soil_moisture(self, timestamp, soil_moisture):
         self._cursor.execute('INSERT INTO soil_moisture VALUES (?, ?)',
                              (timestamp, soil_moisture))
 
-    def get_latest_soil_moisture(self):
+    def latest_soil_moisture(self):
         """Returns the most recent soil moisture reading."""
         query = '''SELECT soil_moisture FROM soil_moisture
                 ORDER BY timestamp DESC

greenpithumb/humidity_sensor.py

@@ -10,6 +10,6 @@ def __init__(self, dht11):
         """
         self._dht11 = dht11
 
-    def get_humidity_level(self):
+    def humidity(self):
         """Returns relative humidity level."""
         return self._dht11.humidity()

greenpithumb/light_sensor.py

@@ -24,18 +24,18 @@ def __init__(self, adc):
         """
         self._adc = adc
 
-    def get_light_level(self):
+    def ambient_light(self):
         """Returns light level as percentage."""
-        light_level = self._adc.read_pin(adc.PIN_LIGHT_SENSOR)
+        ambient_light = self._adc.read_pin(adc.PIN_LIGHT_SENSOR)
 
-        if light_level < _LIGHT_SENSOR_MIN_VALUE:
+        if ambient_light < _LIGHT_SENSOR_MIN_VALUE:
             raise LightSensorLowError(
                 ('Light sensor reading of %i is less than the minimum '
-                 'expected value of %i.') % (light_level,
+                 'expected value of %i.') % (ambient_light,
                                              _LIGHT_SENSOR_MIN_VALUE))
 
-        light_level_as_pct = 100 * (
-            float(light_level - _LIGHT_SENSOR_MIN_VALUE) /
+        ambient_light_as_pct = 100 * (
+            float(ambient_light - _LIGHT_SENSOR_MIN_VALUE) /
             (_LIGHT_SENSOR_MAX_VALUE - _LIGHT_SENSOR_MIN_VALUE))
 
-        return light_level_as_pct
+        return ambient_light_as_pct

greenpithumb/poller.py

@@ -48,7 +48,7 @@ def __init__(self, local_clock, poll_interval, temperature_sensor,
 
     def _poll_once(self):
         """Polls for and stores current ambient temperature."""
-        temperature = self._temperature_sensor.get_temperature()
+        temperature = self._temperature_sensor.temperature()
         self._temperature_store.store_temperature(self._local_clock.now(),
                                                   temperature)
 
@@ -73,7 +73,7 @@ def __init__(self, local_clock, poll_interval, humidity_sensor,
 
     def _poll_once(self):
         """Polls for and stores current relative humidity."""
-        humidity = self._humidity_sensor.get_humidity_level()
+        humidity = self._humidity_sensor.humidity()
         self._humidity_store.store_humidity(self._local_clock.now(), humidity)
 
 
@@ -97,9 +97,9 @@ def __init__(self, local_clock, poll_interval, moisture_sensor,
 
     def _poll_once(self):
         """Polls current soil moisture."""
-        moisture = self._moisture_sensor.moisture()
+        soil_moisture = self._moisture_sensor.moisture()
         self._soil_moisture_store.store_soil_moisture(self._local_clock.now(),
-                                                      moisture)
+                                                      soil_moisture)
 
 
 class AmbientLightPoller(SensorPollerBase):
@@ -122,7 +122,7 @@ def __init__(self, local_clock, poll_interval, light_sensor,
         self._ambient_light_store = ambient_light_store
 
     def _poll_once(self):
-        ambient_light = self._light_sensor.get_light_level()
+        ambient_light = self._light_sensor.ambient_light()
         self._ambient_light_store.store_ambient_light(self._local_clock.now(),
                                                       ambient_light)
 
@@ -184,9 +184,9 @@ def _poll_once(self):
         Polls for latest soil moisture readings and feeds them to a water pump.
         If the pump runs, it stores the event data.
         """
-        moisture = self._soil_moisture_store.get_latest_soil_moisture()
-        if moisture is not None:
-            ml_pumped = self._pump_manager.pump_if_needed(moisture)
+        soil_moisture = self._soil_moisture_store.latest_soil_moisture()
+        if soil_moisture is not None:
+            ml_pumped = self._pump_manager.pump_if_needed(soil_moisture)
             if ml_pumped > 0:
                 self._watering_event_store.store_water_pumped(
                     self._local_clock.now(), ml_pumped)

greenpithumb/temperature_sensor.py

@@ -9,6 +9,6 @@ def __init__(self, dht11):
         """
         self._dht11 = dht11
 
-    def get_temperature(self):
+    def temperature(self):
         """Returns ambient temperature in Celcius."""
         return self._dht11.temperature()

tests/test_db_store.py

@@ -20,18 +20,18 @@ def test_store_soil_moisture(self):
             "INSERT INTO soil_moisture VALUES (?, ?)", (timestamp,
                                                         soil_moisture))
 
-    def test_get_latest_soil_moisture(self):
+    def test_latest_soil_moisture(self):
         mock_cursor = mock.Mock()
         store = db_store.SoilMoistureStore(mock_cursor)
         mock_cursor.fetchall.return_value = [(300,)]
-        moisture = store.get_latest_soil_moisture()
+        moisture = store.latest_soil_moisture()
         self.assertEqual(300, moisture)
 
-    def test_get_latest_soil_moisture_empty_database(self):
+    def test_latest_soil_moisture_empty_database(self):
         mock_cursor = mock.Mock()
         store = db_store.SoilMoistureStore(mock_cursor)
         mock_cursor.fetchall.return_value = []
-        moisture = store.get_latest_soil_moisture()
+        moisture = store.latest_soil_moisture()
         self.assertIsNone(moisture)
 
     def test_store_ambient_light(self):

tests/test_light_sensor.py

@@ -16,12 +16,12 @@ def setUp(self):
     def test_light_50_pct(self):
         """Near midpoint light sensor value should return near 50."""
         self.mock_adc.read_pin.return_value = 656
-        light_level = self.light_sensor.get_light_level()
-        self.assertAlmostEqual(light_level, 49.93178718)
+        ambient_light = self.light_sensor.ambient_light()
+        self.assertAlmostEqual(ambient_light, 49.93178718)
 
-    def test_light_level_too_low(self):
+    def test_ambient_light_too_low(self):
         """Light sensor value less than min should raise a ValueError."""
         with self.assertRaises(light_sensor.LightSensorLowError):
             self.mock_adc.read_pin.return_value = (
                 light_sensor._LIGHT_SENSOR_MIN_VALUE - 1)
-            self.light_sensor.get_light_level()
+            self.light_sensor.ambient_light()

tests/test_poller.py

@@ -27,7 +27,7 @@ def test_temperature_poller(self):
         self.mock_local_clock.now.return_value = TIMESTAMP_A
         self.mock_local_clock.wait.side_effect = (
             lambda _: self.clock_wait_event.set())
-        self.mock_sensor.get_temperature.return_value = 21.0
+        self.mock_sensor.temperature.return_value = 21.0
 
         temperature_poller.start_polling_async()
         self.clock_wait_event.wait(TEST_TIMEOUT_SECONDS)
@@ -41,7 +41,7 @@ def test_humidity_poller(self):
         self.mock_local_clock.now.return_value = TIMESTAMP_A
         self.mock_local_clock.wait.side_effect = (
             lambda _: self.clock_wait_event.set())
-        self.mock_sensor.get_humidity_level.return_value = 50.0
+        self.mock_sensor.humidity.return_value = 50.0
 
         humidity_poller.start_polling_async()
         self.clock_wait_event.wait(TEST_TIMEOUT_SECONDS)
@@ -69,7 +69,7 @@ def test_ambient_light_poller(self):
         self.mock_local_clock.now.return_value = TIMESTAMP_A
         self.mock_local_clock.wait.side_effect = (
             lambda _: self.clock_wait_event.set())
-        self.mock_sensor.get_light_level.return_value = 50.0
+        self.mock_sensor.ambient_light.return_value = 50.0
 
         ambient_light_poller.start_polling_async()
         self.clock_wait_event.wait(TEST_TIMEOUT_SECONDS)
@@ -110,8 +110,7 @@ def test_watering_event_poller_when_pump_run(self):
         self.mock_local_clock.wait.side_effect = (
             lambda _: self.clock_wait_event.set())
         self.mock_pump_manager.pump_if_needed.return_value = 200
-        self.mock_soil_moisture_store.get_latest_soil_moisture.return_value = (
-            100)
+        self.mock_soil_moisture_store.latest_soil_moisture.return_value = 100
 
         watering_event_poller.start_polling_async()
         self.clock_wait_event.wait(TEST_TIMEOUT_SECONDS)
@@ -127,8 +126,7 @@ def test_watering_event_poller_when_pump_not_run(self):
         self.mock_local_clock.wait.side_effect = (
             lambda _: self.clock_wait_event.set())
         self.mock_pump_manager.pump_if_needed.return_value = 0
-        self.mock_soil_moisture_store.get_latest_soil_moisture.return_value = (
-            500)
+        self.mock_soil_moisture_store.latest_soil_moisture.return_value = 500
 
         watering_event_poller.start_polling_async()
         self.clock_wait_event.wait(TEST_TIMEOUT_SECONDS)
@@ -143,8 +141,7 @@ def test_watering_event_poller_when_moisture_is_None(self):
             self.mock_watering_event_store, self.mock_soil_moisture_store)
         self.mock_local_clock.wait.side_effect = (
             lambda _: self.clock_wait_event.set())
-        self.mock_soil_moisture_store.get_latest_soil_moisture.return_value = (
-            None)
+        self.mock_soil_moisture_store.latest_soil_moisture.return_value = None
 
         watering_event_poller.start_polling_async()
         self.clock_wait_event.wait(TEST_TIMEOUT_SECONDS)