def test_controller_tick(self):
"""test the tick function in the controller"""
sensor = Sensor('127.0.0.1', 8000)
pump = Pump('127.0.0.1', 8000)
dec = Decider(100, .05)
con = Controller(sensor, pump, dec)
# liquid height
sensor.measure = MagicMock(return_value=94)
# state of pump
pump.get_state = MagicMock(return_value=pump.PUMP_IN)
# decider next state for pump
dec.decide = MagicMock(return_value=pump.PUMP_IN)
# this line was added to fix my error
pump.set_state = MagicMock(return_value=True)
con.tick()
sensor.measure.assert_called_with()
pump.get_state.assert_called_with()
dec.decide.assert_called_with(94, pump.PUMP_IN, actions)
def test_decider(testcase, em):
"""
Adds a new backup every day of 2015, checks list of backups
2nd of each month.
"""
decider = Decider(em, {
'monthly': 2,
'weekly': 3,
'daily': 5,
})
d = date(2015, 1, 1)
while True:
#print('-->', d)
# add entry
stamp = 'daily'
if d.isoweekday() == 1: stamp = 'weekly'
if d.day == 1: stamp = 'monthly'
stamp = str(d.year) + str(d.month).zfill(2) + str(
d.day).zfill(2) + '-2330-' + stamp
em._add(stamp)
decider.execute()
# if we're on checkpoint, compare
if d.day == 2:
testcase.assertEqual(em.list(), expected_results[d.month])
# ok, go next
d += timedelta(days=1)
if d > date(2015, 12, 31):
break
def test_module(self):
"""
Go through various sensor.measure and pump.get_state values to verify
the compatibility of decider and controller.
"""
dec = Decider(100, .05)
control = Controller(
Sensor("127.0.0.1", "8000"),
Pump("127.0.0.1", "8000"),
dec
)
control.pump.set_state = MagicMock(return_value=True)
levels = [110, 90, 99]
for pump_act in control.actions.values():
control.pump.get_state = MagicMock(return_value=pump_act)
for water_h in levels:
control.sensor.measure = MagicMock(return_value=water_h)
control.tick()
control.pump.get_state = MagicMock(
return_value=dec.decide(
control.sensor.measure(),
control.pump.get_state(),
control.actions
)
)
def setUp(self):
"""Set up decider for tests"""
self.actions = {
'PUMP_IN': 'PUMP_IN',
'PUMP_OUT': 'PUMP_OUT',
'PUMP_OFF': 'PUMP_OFF'
}
self.decider = Decider(10, 0.05)
def setUp(self):
"""Run each time before any test method is run."""
self.pump = Pump('127.0.0.1', 8000)
self.actions = {
'PUMP_IN': self.pump.PUMP_IN,
'PUMP_OUT': self.pump.PUMP_OUT,
'PUMP_OFF': self.pump.PUMP_OFF,
}
self.decider = Decider(100, 0.05)
def test_decide(self):
decider = Decider(100, 0.05)
self.assertEqual(ACTIONS['PUMP_IN'], decider.decide(90, ACTIONS['PUMP_OFF'], ACTIONS))
self.assertEqual(ACTIONS['PUMP_OUT'], decider.decide(110, ACTIONS['PUMP_OFF'], ACTIONS))
self.assertEqual(ACTIONS['PUMP_OFF'], decider.decide(95, ACTIONS['PUMP_OFF'], ACTIONS))
self.assertEqual(ACTIONS['PUMP_OFF'], decider.decide(105, ACTIONS['PUMP_OFF'], ACTIONS))
self.assertEqual(ACTIONS['PUMP_OFF'], decider.decide(110, ACTIONS['PUMP_IN'], ACTIONS))
self.assertEqual(ACTIONS['PUMP_IN'], decider.decide(90, ACTIONS['PUMP_IN'], ACTIONS))
self.assertEqual(ACTIONS['PUMP_OFF'], decider.decide(90, ACTIONS['PUMP_OUT'], ACTIONS))
self.assertEqual(ACTIONS['PUMP_OUT'], decider.decide(110, ACTIONS['PUMP_OUT'], ACTIONS))
def second_decider_test(self, address, port):
'''Behavior Test: If the pump is off and the height is above the margin region, then the
pump should be turned to PUMP_OUT.'''
logger.info("running second decider test")
my_pump = Pump(address, port)
my_sensor = Sensor(address, port)
my_decider = Decider(10, 1)
my_controller = Controller(my_sensor, my_pump, my_decider)
try:
self.assertequals(my_decider.decide(12, 0, my_controller.actions),
-1)
except Exception as exception:
logger.critical(exception)
def setUp(self):
"""Set up controller for test"""
self.sensor = Sensor('127.0.0.1', 8000)
self.pump = Pump('127.0.0.1', 8000)
self.decider = Decider(10, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def test_tick(self):
"""
Testing the tick method in controller
"""
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
decider = Decider(100, .05)
controller = Controller(sensor, pump, decider)
sensor.measure = MagicMock(return_value=95)
pump.get_state = MagicMock(return_value=pump.PUMP_IN)
decider.decide = MagicMock(return_value=pump.PUMP_IN)
pump.set_state = MagicMock(return_value=True)
controller.tick()
sensor.measure.assert_called_with()
pump.get_state.assert_called_with()
decider.decide.assert_called_with(95, pump.PUMP_IN, actions)
class ModuleTests(unittest.TestCase):
"""
Module tests for the water-regulation module
"""
def test_module(self):
"""Test the water regulation module."""
self.ip_addr = '127.0.0.1'
self.port = '8000'
urllib.request.urlopen = MagicMock(return_value=5)
self.sensor = Sensor(self.ip_addr, self.port)
self.pump = Pump(self.ip_addr, self.port)
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
self.controller.pump.set_state = MagicMock(return_value=True)
for action in self.controller.actions.values():
for height in range(89 - 111):
self.controller.sensor.measure = MagicMock(return_value=height)
# Line too long, but impossible to shorten
self.controller.pump.get_state = \
MagicMock(return_value=self.decider.decide(height,
action,
self.controller.actions))
self.controller.tick()
def fourth_decider_test(self, address, port):
'''Behavior Test: If the pump is performing PUMP_IN and the height is above the target
height, then the pump shall be turned to PUMP_OFF, otherwise the pump
shall remain at PUMP_IN.'''
logger.info("running fourth decider test")
my_pump = Pump(address, port)
my_sensor = Sensor(address, port)
my_decider = Decider(10, 1)
my_controller = Controller(my_sensor, my_pump, my_decider)
try:
self.assertequals(
my_decider.decide(my_decider.target_height + 1, 1,
my_controller.actions), 0)
except Exception as exception:
logger.critical(exception)
def setUp(self):
"""
Sets up controller.
"""
self.sensor = Sensor("127.0.0.1", "8000")
self.pump = Pump("127.0.0.1", "8000")
self.decider = Decider(100, .05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def third_controller_test(self, address, port):
'''Tests the ability to query the decider for the next appropriate state
given a set of starting conditions. Note, this will only test one set of starting
conditions. Exhaustive testing of the deciders logic is performed in DeciderTests'''
if True:
logger.info("Starting third controller test")
#Creating pump, sensor, and decider for test case
my_pump = Pump(address, port)
my_sensor = Sensor(address, port)
my_decider = Decider(10, 1)
#Passing pump, sensor, and decider to controller
my_controller = Controller(my_sensor, my_pump, my_decider)
logger.info("Done with third controller test")
my_decider.decide(500, my_decider.target_height,
my_controller.actions)
def test_tick(self):
"""
Testing the tick method in controller
:return:
"""
p = Pump('127.0.0.1', 8080)
s = Sensor('127.0.0.1', 8083)
d = Decider(100, .10)
c = Controller(s, p, d)
s.measure = MagicMock(return_value=95)
p.get_state = MagicMock(return_value=p.PUMP_IN)
d.decide = MagicMock(return_value=p.PUMP_IN)
p.set_state = MagicMock(return_value=True)
c.tick()
s.measure.assert_called_with()
p.get_state.assert_called_with()
d.decide.assert_called_with(95, p.PUMP_IN, actions)
def test_water(self):
"""
the test method
"""
pump = Pump('127.0.0.1', '8000')
decider = Decider(100, 2)
sensor = Sensor('127.0.0.1', '8000')
controller = Controller(sensor, pump, decider)
controller.pump.set_state = MagicMock(return_value=True)
controller.pump.get_state = MagicMock(return_value=True)
# level = [100, 100, 95]
for act in controller.actions.values():
for level in range(0, 200, 1):
controller.sensor.measure = MagicMock(return_value=level)
controller.pump.get_state = MagicMock(return_value=decider.decide(level, act, controller.actions))
controller.pump.set_state = MagicMock(return_value=True)
controller.tick()
def test_app(self):
"""
Testing the app
:return:
"""
p = Pump('127.0.0.1', '8080')
s = Sensor('127.0.0.1', '8083')
d = Decider(100, .10)
c = Controller(s, p, d)
c.pump.set_state = MagicMock(return_value=True)
for action in c.actions.values():
for water_level in range(50, 150, 5):
# measuring the water level
c.sensor.measure = MagicMock(return_value=water_level)
# getting the state of the pump
c.pump.get_state = MagicMock(return_value=d.decide(water_level, action, c.actions))
# running the tick functions
c.tick()
def test_tick(self):
"""
Tests each tick
"""
pump = Pump('127.0.0.1', '8000')
decider = Decider(100, 2)
sensor = Sensor('127.0.0.1', '8000')
controller = Controller(sensor, pump, decider)
sensor.measure = MagicMock(return_value=102)
pump.set_state = MagicMock(return_value=pump.PUMP_OFF)
pump.get_state = MagicMock(return_value=pump.PUMP_OFF)
decider.decide = MagicMock(return_value=pump.PUMP_OFF)
controller.tick()
sensor.measure.assert_called_with()
pump.get_state.assert_called_with()
decider.decide.assert_called_with(102, pump.PUMP_OFF,
controller.actions)
def test_water(self):
"""
Integration test
"""
pump_address = Pump('127.0.0.1', '8000')
sensor_address = Sensor('127.0.0.1', '8000')
decider_vals = Decider(1000.0, .10)
controller_all = Controller(sensor_address, pump_address, decider_vals)
controller_all.pump.set_state = MagicMock(return_value=True)
for action in controller_all.actions.values():
for water_level in range(500, 2000, 50):
controller_all.sensor.measure = MagicMock(
return_value=water_level)
controller_all.pump.get_state = MagicMock(
return_value=decider_vals.decide(water_level, action,
controller_all.actions))
self.assertTrue(controller_all.tick())
def test_tick(self):
"""
Testing the tick method in controller
:return:
"""
pump_address = Pump('127.0.0.1', 8000)
sensor_address = Sensor('127.0.0.1', 8000)
decider_vals = Decider(100, .10)
controller_all = Controller(sensor_address, pump_address, decider_vals)
sensor_address.measure = MagicMock(return_value=95)
pump_address.get_state = MagicMock(return_value=pump_address.PUMP_IN)
decider_vals.decide = MagicMock(return_value=pump_address.PUMP_IN)
pump_address.set_state = MagicMock(return_value=True)
controller_all.tick()
sensor_address.measure.assert_called_with()
pump_address.get_state.assert_called_with()
decider_vals.decide.assert_called_with(95, pump_address.PUMP_IN,
actions)
def setUp(self):
"""A controller with basic configuration."""
self.ip_addr = '127.0.0.1'
self.port = '8000'
urllib.request.urlopen = MagicMock(return_value=5)
self.sensor = Sensor(self.ip_addr, self.port)
self.pump = Pump(self.ip_addr, self.port)
self.pump.set_state(MagicMock(return_value=True))
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def third_decider_test(self, address, port):
'''Behavior Test: If the pump is off and the height is within the margin region or on
the exact boundary of the margin region, then the pump shall remain at
PUMP_OFF.'''
logger.info("running third decider test")
my_pump = Pump(address, port)
my_sensor = Sensor(address, port)
my_decider = Decider(10, 1)
my_controller = Controller(my_sensor, my_pump, my_decider)
try:
self.assertequals(
my_decider.decide(my_decider.target_height + my_decider.margin,
0, my_controller.actions), 0)
self.assertequals(
my_decider.decide(my_decider.target_height - my_decider.margin,
0, my_controller.actions), 0)
except Exception as exception:
logger.critical(exception)
def create_instance(address, port, target_height, margin):
'''helper method to create new pump, sensor, decider, and controller
for each test'''
my_pump = Pump(address, port)
my_sensor = Sensor(address, port)
my_decider = Decider(target_height, margin)
#Passing pump, sensor, and decider to controller
my_controller = Controller(my_sensor, my_pump, my_decider)
logger.info("succesfully created controller instance")
class DeciderTests(unittest.TestCase):
"""Unit tests for the Decider class"""
def setUp(self):
"""Set up each test with an actions dict"""
self.actions = {'PUMP_IN': 1, 'PUMP_OFF': 0, 'PUMP_OUT': -1}
self.decider = Decider(100, 0.05)
def test_pump_off_and_height_below_margin(self):
"""
1. If the pump is off and the height is below the margin region,
then the pump should be turned to PUMP_IN.
"""
self.assertEqual(1, self.decider.decide(101, 0, self.actions))
def test_pump_off_and_height_above_margin(self):
"""
2. If the pump is off and the height is above the margin region,
then the pump should be turned to PUMP_OUT.
"""
self.assertEqual(-1, self.decider.decide(106, 0, self.actions))
def test_pump_off_and_height_is_above_target_but_equal_margin(self):
"""
3. If the pump is off and the height is within the margin region
or on the exact boundary of the margin region, then the pump shall
remain at PUMP_OFF.
"""
self.assertEqual(0, self.decider.decide(105, 0, self.actions))
def test_pump_on_and_height_above_margin(self):
"""
4a. If the pump is performing PUMP_IN and the height is above the target
height, then the pump shall be turned to PUMP_OFF
"""
self.assertEqual(0, self.decider.decide(110, 1, self.actions))
def test_pump_on_and_height_below_margin(self):
"""
4b. If the pump is performing PUMP_IN and the height is below the target
height, then the pump shall remain PUMP_IN
"""
self.assertEqual(1, self.decider.decide(99, 1, self.actions))
def test_pump_out_and_height_below_margin(self):
"""
5a. If the pump is performing PUMP_OUT and the height is below the target
height, then the pump shall be turned to PUMP_OFF
"""
self.assertEqual(0, self.decider.decide(90, -1, self.actions))
def test_pump_out_and_height_above_margin(self):
"""
5b. If the pump is performing PUMP_OUT and the height is above the target
height, then the pump shall remain PUMP_OUT
"""
self.assertEqual(-1, self.decider.decide(190, -1, self.actions))
def setUp(self):
"""Run each time before any test method is run."""
self.sensor = Sensor('http://127.0.0.1', '8000')
self.pump = Pump('http://127.0.0.1', '8000')
self.decider = Decider(100, 0.05)
self.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 integration_test(self):
'''Uses mocked Sensor and Pump as inputs into a decider and controller,
tests controller output for given inputs'''
'''For the integration check we are only checking the end result of our function calls,
in this case the ability to correctly return true from teh set_state function with
the previous functions as inputs'''
actions = {'PUMP_IN': 1, 'PUMP_OFF': 0, 'PUMP_OUT': -1}
logger.info("Begininning integration_test")
my_decider = Decider(5.0, 1)
my_controller = Controller(self.Sensor, self.Pump, my_decider)
print(
my_decider.decide(self.Sensor.measure(), self.Pump.get_state,
actions))
#Tick Behavior 4
assert my_controller.Pump.set_state(
my_decider.decide(self.Sensor.measure(), self.Pump.get_state,
actions)) == True
#Final check
assert my_controller.tick() == None
def test_decider_decide(self):
"""
Unit test for decider
"""
deciders = Decider(100, .05)
self.assertEqual(1, deciders.decide(90, actions['PUMP_OFF'], actions))
self.assertEqual(1, deciders.decide(90, actions['PUMP_IN'], actions))
self.assertEqual(-1, deciders.decide(120, actions['PUMP_OFF'],
actions))
self.assertEqual(-1, deciders.decide(120, actions['PUMP_OUT'],
actions))
self.assertEqual(0, deciders.decide(100, actions['PUMP_OFF'], actions))
self.assertEqual(0, deciders.decide(120, actions['PUMP_IN'], actions))
self.assertEqual(0, deciders.decide(90, actions['PUMP_OUT'], actions))
def main():
print("Plasma 1.0")
print("- written by m1kc")
print("- https://github.com/m1kc/plasma-backup")
print("- licensed under GNU GPL v3")
print("")
print("THIS SOFTWARE IS STILL EXPERIMENTAL.")
print("USE AT YOUR OWN RISK.")
print("")
path = sys.argv[1]
print("Rotating entries in:", path)
config = load_json(os.path.join(path, FILENAME))
em = EntryManagerFilesystem(path)
d = Decider(em, config['policy'])
print("Entries exist:", len(em.list()))
d.execute()
print("Everything's fine, exiting.")
def test_tick(self):
"""Method docstring."""
ACTIONS = {'PUMP_IN': 1, 'PUMP_OFF': 0, 'PUMP_OUT': -1}
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_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_tick(self):
self.sensor = Sensor('127.0.0.1', '8000')
self.pump = Pump('127.0.0.1', '8000')
self.decider = Decider(100, 0.05)
self._controller = controller.Controller(self.sensor, self.pump, self.decider)
self.pump.set_state = MagicMock(return_value=True)
self.pump.get_state = MagicMock(return_value=True)
self.sensor.measure = MagicMock(return_value=True)
self.decider.decide = MagicMock(return_value=True)
self._controller.tick()
self.pump.set_state.assert_called_with(True)
self.pump.get_state.assert_called_with()
self.sensor.measure.assert_called_with()
self.decider.decide.assert_called_with(True, True, ACTIONS)
