def test_decider_current_action_pumpoff_height_in_target_and_margin_range(
self):
decider = Decider(target_height=5000, margin=1000)
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
controller = Controller(sensor, pump, decider)
#equal to target + margin case
result = decider.decide(current_height=4000,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OFF)
#equal to target + margin case
result = decider.decide(current_height=4000,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OFF)
#in the range of (target - margin to target + margin)
result = decider.decide(current_height=5800,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OFF)
#in the range of (target - margin to target + margin)
result = decider.decide(current_height=4200,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OFF)
def setUp(self):
self.decider_dict = {
'PUMP_OFF': 'maintain current level',
'PUMP_IN': 'pump water in',
'PUMP_OUT': 'pump water out'
}
self.decider = Decider(120, 0.05)
def test_decide(self):
"""
Test decide method of Decider class:
P1: If PUMP_OFF, and levels are below margin,
decider.decide should choose to PUMP_IN
P2: If PUMP_OFF, and levels are higher than
margin, decider.decide should choose to
PUMP_OUT
P3: If PUMP_OFF and levels are within margin,
decider.decide should keep pump at PUMP_OFF
P4a: If pump is set to PUMP_IN and levels
exceed margin tolerance, decider.decide should
set pump to PUMP_OFF
P4b: If pump is set to PUMP_IN and levels
do not exceed margin tolerance, decider.decide
should not change state
P5a: If pump is set to PUMP_OUT and levels drop
below margin, decider.decide should set pump to
PUMP_OFF
P5b: If pump is set to PUMP_OUT and levels are
above margin, pump should not change state
"""
decider = Decider(100, .10)
self.assertEqual(1, decider.decide(88, 0, self.actions)) # /P1
self.assertEqual(-1, decider.decide(120, 0, self.actions)) # /P2
self.assertEqual(0, decider.decide(101, 0, self.actions)) # /P3
self.assertEqual(0, decider.decide(111, 1, self.actions)) # /P4a
self.assertEqual(1, decider.decide(100, 1, self.actions)) # /P4b
self.assertEqual(0, decider.decide(89, -1, self.actions)) # /P5a
self.assertEqual(-1, decider.decide(111, -1, self.actions)) # /P5b
def setUp(self):
"""
This method does a setup for integration testing raterregulation
"""
self.pump = Pump('127.0.0.1', 1000)
self.sensor = Sensor('127.0.0.2', 2000)
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def setUp(self):
"""
Instantiates the pump, decider, sensor and controller classes
"""
self.pump = Pump('127.0.0.1', 514)
self.sensor = Sensor('127.0.0.1', 514)
self.decider = Decider(100, .01)
self.controller = Controller(self.sensor, self.pump, self.decider)
def setUp(self):
"""
Create instance for testing
"""
self.decider = Decider(100, 0.05)
self.pump = Pump('127.0.0.1', 8000)
self.sensor = Sensor('127.0.0.1', 8000)
self.controller = Controller(self.sensor, self.pump, self.decider)
def test_decider_current_action_pump_off_height_less_than_target(self):
decider = Decider(target_height=10000, margin=1000)
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
controller = Controller(sensor, pump, decider)
result = decider.decide(current_height=5000,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_IN)
def setUp(self):
"""
This method does a setup for unit testing Controller
"""
self.pump = Pump('127.0.0.1', 1000)
self.sensor = Sensor('127.0.0.2', 2000)
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def setUp(self):
self.sensor = Sensor('127.0.0.1', '8001')
self.pump = Pump('127.0.0.1', '8000')
self.decider = Decider(5, .05)
self.new_controller = Controller(self.sensor, self.pump, self.decider)
self.actions = {
'PUMP_IN': self.pump.PUMP_IN,
'PUMP_OUT': self.pump.PUMP_OUT,
'PUMP_OFF': self.pump.PUMP_OFF,
}
def setUp(self):
"""Setup DeciderTests"""
self.sensor = Sensor('127.0.0.1', 8001)
self.pump = Pump('127.0.0.1', 8000)
self.decider = Decider(5, .05)
self.actions = {
'PUMP_IN': self.pump.PUMP_IN,
'PUMP_OUT': self.pump.PUMP_OUT,
'PUMP_OFF': self.pump.PUMP_OFF,
}
def setUp(self):
"""
setup
:return:
"""
self.pump = Pump('127.0.0.1', 8000)
self.sensor = Sensor('127.1.1.3', 9000)
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def test_decider_current_action_pumpoff_height_greater_target_and_margin(
self):
decider = Decider(target_height=1000, margin=200)
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
controller = Controller(sensor, pump, decider)
result = decider.decide(current_height=1250,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OUT)
def test_integration_set_pump_state_fail(self):
decider = Decider(target_height=3000, margin=500)
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=False)
pump.get_state = MagicMock(return_value=Pump.PUMP_OFF)
sensor.measure = MagicMock(return_value=3500)
controller = Controller(sensor, pump, decider)
result = controller.tick()
self.assertEqual(result, False)
def test_integration(self):
"""Method docstring."""
sensor = Sensor(self.address, self.port)
pump = Pump(self.address, self.port)
decider = Decider(100, .05)
controller = Controller(sensor, pump, decider)
for level in range(0, 200, 10):
for action in controller.actions.values():
sensor.measure = MagicMock(return_value=level)
pump.get_state = MagicMock(return_value=action)
pump.set_state = MagicMock(return_value=True)
controller.tick()
pump.set_state = MagicMock(return_value=False)
controller.tick()
def test_controller_tick(self):
"""Tests if, on each call to tick(), the controller object
queries each of the sensor, pump, and decider, then sets pump
to new state
"""
sensor = Sensor('127.0.0.1', '514')
sensor.measure = MagicMock(return_value=105)
pump = Pump('127.0.0.1', '8000')
pump.get_state = MagicMock(return_value='PUMP_OFF')
pump.set_state = MagicMock(return_value='PUMP_IN')
decider = Decider(120, 0.05)
controller = Controller(sensor, pump, decider)
self.assertTrue(controller.tick())
def test_module(self):
"""
Tests the functionality of the water regulation classes and methods
within those classes
"""
self.pump = Pump('0.0.0.0', 514)
self.sensor = Sensor('0.0.0.0', 514)
self.decider = Decider(100,.01)
self.control = Controller(self.sensor, self.pump, self.decider)
self.pump.get_state = MagicMock(return_value = 0)
current_state = self.pump.get_state()
self.sensor.measure = MagicMock(return_value = 50)
current_height = self.sensor.measure()
new_state = self.decider.decide(current_height, current_state, self.control.actions)
self.assertEqual(1, new_state)
def setUp(self):
"""
Set up method for test_controller
"""
self.sensor = Sensor('127.0.0.1', 8000)
self.sensor.measure = MagicMock(return_value=100)
self.pump = Pump('127.0.0.1', 8000)
self.pump.set_state = MagicMock(return_value=True)
self.pump.get_state = MagicMock(return_value=self.pump.PUMP_OFF)
self.decider = Decider(100, .10)
self.decider.decide = MagicMock(return_value=self.pump.PUMP_OFF)
self.controller = Controller(self.sensor, self.pump, self.decider)
self.controller.tick()
self.actions = {
'PUMP_IN': self.pump.PUMP_IN,
'PUMP_OUT': self.pump.PUMP_OUT,
'PUMP_OFF': self.pump.PUMP_OFF
}
def test_all(self):
"""
Run full test on all components of waterregulation
"""
pump_address = Pump('127.0.0.1', '2048')
sensor_address = Sensor('127.0.0.1', '2048')
decider_margins = Decider(100, .10)
controller_all = Controller(sensor_address, pump_address,
decider_margins)
controller_all.pump.set_state = MagicMock(return_value=True)
for action in controller_all.actions.values():
for water_level in range(25, 150, 100):
# water level (mocked)
controller_all.sensor.measure = \
MagicMock(return_value=water_level)
# pump state (mocked)
controller_all.pump.get_state = MagicMock(
return_value=decider_margins.decide(
water_level, action, controller_all.actions))
controller_all.tick()
def test_tick(self):
"""Method docstring."""
pump_address = Pump('127.0.0.1', 8000)
sensor_address = Sensor('127.0.0.1', 8000)
decider_vals = Decider(100, 5)
controller_all = Controller(sensor_address, pump_address, decider_vals)
sensor_address.measure = MagicMock(return_value=90)
pump_address.get_state = MagicMock(return_value=pump_address.PUMP_OFF)
decider_vals.decide_pump_action = MagicMock(
return_value=pump_address.PUMP_IN)
pump_address.set_state = MagicMock(return_value=True)
controller_all.tick()
pump_address.get_state = MagicMock(return_value=pump_address.PUMP_IN)
controller_all.tick()
pump_address.get_state = MagicMock(return_value=pump_address.PUMP_OUT)
controller_all.tick()
sensor_address.measure.assert_called_with()
pump_address.get_state.assert_called_with()
pump_address.set_state.assert_called_with(pump_address.PUMP_OFF)
def test_dummy(self):
"""
Just some example syntax that you might use
"""
pump = Pump('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=True)
actions = {
'PUMP_IN': Pump.PUMP_IN,
'PUMP_OUT': Pump.PUMP_OUT,
'PUMP_OFF': Pump.PUMP_OFF
}
target = 100
margin = 5
above = 107
below = 92
between = 102
decider = Decider(target, margin)
pump_off = decider.decide_pump_action(0, actions)
pump_in = decider.decide_pump_action(1, actions)
pump_out = decider.decide_pump_action(-1, actions)
height_above = decider.height_checker(above)
height_below = decider.height_checker(below)
height_between = decider.height_checker(between)
self.assertEqual(pump_off(height_above), Pump.PUMP_OUT)
self.assertEqual(pump_off(height_below), Pump.PUMP_IN)
self.assertEqual(pump_off(height_between), Pump.PUMP_OFF)
self.assertEqual(pump_in(height_above), Pump.PUMP_OFF)
self.assertEqual(pump_in(height_below), Pump.PUMP_IN)
self.assertEqual(pump_in(height_between), Pump.PUMP_IN)
self.assertEqual(pump_out(height_above), Pump.PUMP_OUT)
self.assertEqual(pump_out(height_below), Pump.PUMP_OFF)
self.assertEqual(pump_out(height_between), Pump.PUMP_OUT)
def setUp(self):
"""
setup
:return:
"""
self.decider = Decider(100, 0.05)
def setUp(self):
self.decider = Decider(self.target, self.margin)
def setUp(self):
self.pump = Pump(self.addr, self.port)
self.sensor = Sensor(self.addr, self.port)
self.decider = Decider(self.target, self.margin)
self.controller = Controller(self.sensor, self.pump, self.decider)
def setUp(self):
"""
This method does a setup for unit testing Decider
"""
self.decider = Decider(100, 0.05)
def test_bad_height_setting(self):
"""Raise Exception for Bad Height Setting"""
with self.assertRaises(Exception):
self.decider = Decider(-1, .05)
def setUp(self):
self.decider = Decider(100, 0.05)
self.pump = Pump('127.0.0.1', 8000)
self.sensor = Sensor('127.0.0.1', 8000)
self.controller = Controller(self.sensor, self.pump, self.decider)