def testOnSwitchTurnedOn_withApplicableZone_returnsTrue(self):
zone = Zone('ff', [self.light, self.motionSensor])
self.zm.addZone(zone)
self.assertTrue(
self.zm.onSwitchTurnedOn(scope.events, self.light.getItem()))
def testOnSwitchTurnedOff_noZone_returnsFalse(self):
self.assertFalse(
self.zm.onSwitchTurnedOff(scope.events,
PE.createStringItem(INVALID_ITEM_NAME)))
def testOnSwitchTurnedOff_withNonApplicableZone_returnsFalse(self):
zone = Zone('ff', [self.light, self.motionSensor])
self.zm.addZone(zone)
self.assertFalse(
self.zm.onSwitchTurnedOff(scope.events,
PE.createStringItem(INVALID_ITEM_NAME)))
def testOnSwitchTurnedOff_withApplicableZone_returnsTrue(self):
zone = Zone('ff', [self.light, self.motionSensor])
self.zm.addZone(zone)
self.assertTrue(
self.zm.onSwitchTurnedOff(scope.events, self.light.getItem()))
PE.runUnitTest(ZoneManagerTest)
def createTestData(self, excludedDevices=[], extraIncludedDevices=[]):
'''
:return: a list of two zones, the mocked zone manager, and the event dispatcher
:rtype: list
'''
self.partition.armAway(self.getMockedEventDispatcher())
porch = Zone.createExternalZone('porch').addDevice(self.partition)
greatRoom = Zone("GR", [self.audioSink], Level.FIRST_FLOOR)
for d in excludedDevices:
if porch.hasDevice(d):
porch = porch.removeDevice(d)
if greatRoom.hasDevice(d):
greatRoom = greatRoom.removeDevice(d)
for d in extraIncludedDevices:
greatRoom = greatRoom.addDevice(d)
zm = MockedZoneManager([porch, greatRoom])
eventInfo = EventInfo(ZoneEvent.MOTION, ITEMS[0], porch, zm,
self.getMockedEventDispatcher())
return [porch, greatRoom, zm, eventInfo]
PE.runUnitTest(SimulateDaytimePresenceTest)
self.assertFalse(self.lobby.isLightOn())
def testOnAction_openSpaceButDisableTurnOffByNeightbor_mustNotTurnsOffLight(
self):
self.lightItem3.setState(scope.OnOffType.ON)
self.assertTrue(self.turnOff(self.lobby))
self.assertTrue(self.foyer.isLightOn())
def testOnAction_fanZone_returnsFalse(self):
self.fanItem.setState(scope.OnOffType.ON)
self.assertFalse(self.turnOff(self.shower))
def testOnAction_neighborWithFan_mustNotTurnOffNeighborFan(self):
self.fanItem.setState(scope.OnOffType.ON)
self.lightItem2.setState(scope.OnOffType.ON)
self.assertTrue(self.turnOff(self.washroom))
self.assertFalse(self.lobby.isLightOn())
self.assertEqual(scope.OnOffType.ON, self.fanItem.getState())
def turnOff(self, zone):
eventInfo = EventInfo(ZoneEvent.SWITCH_TURNED_ON, ITEMS[0],
zone, self.zoneManager,
self.getMockedEventDispatcher())
return TurnOffAdjacentZones().onAction(eventInfo)
PE.runUnitTest(TurnOffAdjacentZonesTest)
def testGetNeighborZones_noNeighborTypesSpecified_returnsCorrectList(self):
zone1 = Zone('foyer')
zone2 = Zone('porch')
zone3 = Zone('office')
zone1 = zone1.addNeighbor(
Neighbor(zone2.getId(), NeighborType.OPEN_SPACE))
zone1 = zone1.addNeighbor(
Neighbor(zone3.getId(), NeighborType.OPEN_SPACE_MASTER))
zm = MockedZoneManager([zone1, zone2, zone3])
self.assertEqual(2, len(zone1.getNeighborZones(zm)))
def testGetNeighborZones_neighborTypeSpecified_returnsCorrectList(self):
zone1 = Zone('foyer')
zone2 = Zone('porch')
zone3 = Zone('office')
zone1 = zone1.addNeighbor(
Neighbor(zone2.getId(), NeighborType.OPEN_SPACE))
zone1 = zone1.addNeighbor(
Neighbor(zone3.getId(), NeighborType.OPEN_SPACE_MASTER))
zm = MockedZoneManager([zone1, zone2, zone3])
zones = zone1.getNeighborZones(zm, [NeighborType.OPEN_SPACE_MASTER])
self.assertEqual(1, len(zones))
self.assertEqual(zone3, zones[0])
PE.runUnitTest(ZoneTest)
def testFromJson_invalidLevel_raiseException(self):
json = '{' + '"subject":"{}","body":"{}","level":"blah"'.format(
SUBJECT, BODY) + '}'
with self.assertRaises(ValueError) as cm:
alert = Alert.fromJson(json)
def testFromJson_withSubjectBodyAndModule_returnsNewObject(self):
json = '{' + '"subject":"{}","body":"{}","module":"{}","intervalBetweenAlertsInMinutes":{}'.format(
SUBJECT, BODY, MODULE, INTERVAL_BETWEEN_ALERTS_IN_MINUTES) + '}'
alert = Alert.fromJson(json)
self.assertEqual(SUBJECT, alert.getSubject())
self.assertEqual(BODY, alert.getBody())
self.assertEqual(MODULE, alert.getModule())
self.assertEqual(INTERVAL_BETWEEN_ALERTS_IN_MINUTES,
alert.getIntervalBetweenAlertsInMinutes())
self.assertTrue(alert.isInfoLevel())
def testFromJson_missingIntervalBetweenAlertsInMinutes_returnsNewObject(
self):
json = '{' + '"subject":"{}","body":"{}","module":"{}"'.format(
SUBJECT, BODY, MODULE) + '}'
with self.assertRaises(ValueError) as cm:
alert = Alert.fromJson(json)
self.assertEqual('Invalid intervalBetweenAlertsInMinutes value: -1',
cm.exception.args[0])
PE.runUnitTest(AlertTest)
# initially below threshold
ITEMS[0].setState(DecimalType(20))
self.sendEventAndAssertAlertContainMessage('below the threshold')
# now back to normal
ITEMS[0].setState(DecimalType(40))
self.sendEventAndAssertAlertContainMessage('back to the normal range')
def sendEventAndAssertNoAlert(self):
AlertManager.reset()
eventInfo = EventInfo(ZoneEvent.TEMPERATURE_CHANGED,
ITEMS[0], self.zone1, None,
self.getMockedEventDispatcher())
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertEqual(None, AlertManager._lastEmailedSubject)
def sendEventAndAssertAlertContainMessage(self, message):
AlertManager.reset()
eventInfo = EventInfo(ZoneEvent.TEMPERATURE_CHANGED,
ITEMS[0], self.zone1, None,
self.getMockedEventDispatcher())
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertTrue(message in AlertManager._lastEmailedSubject)
PE.runUnitTest(AlertOnTemperatureOutOfRangeTest)
self.sendEventAndAssertNoAlert()
def testOnAction_humidityBackToNormal_returnsTrueAndSendsInfoAlert(self):
# initially below threshold
ITEMS[0].setState(DecimalType(20))
self.sendEventAndAssertAlertContainMessage('below the threshold')
# now back to normal
ITEMS[0].setState(DecimalType(40))
self.sendEventAndAssertAlertContainMessage('back to the normal range')
def sendEventAndAssertNoAlert(self):
AlertManager.reset()
eventInfo = EventInfo(ZoneEvent.HUMIDITY_CHANGED, ITEMS[0], self.zone1,
None, self.getMockedEventDispatcher())
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertEqual(None, AlertManager._lastEmailedSubject)
def sendEventAndAssertAlertContainMessage(self, message):
AlertManager.reset()
eventInfo = EventInfo(ZoneEvent.HUMIDITY_CHANGED, ITEMS[0], self.zone1,
None, self.getMockedEventDispatcher())
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertTrue(message in AlertManager._lastEmailedSubject)
PE.runUnitTest(AlertOnHumidityOutOfRangeTest)
(zone, zm, eventInfo) = self.createTestData(
ZoneEvent.PARTITION_DISARMED_FROM_AWAY)
self.assertTrue(zone.isLightOn())
self.invokeActionAndAssertDevicesTurnedOff(zone, eventInfo)
def invokeActionAndAssertDevicesTurnedOff(self, zone, eventInfo):
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertFalse(zone.isLightOn())
self.assertEqual("pause", self.audioSink._getLastTestCommand())
def createTestData(self, zoneEvent):
'''
:return: a list of two zones, the mocked zone manager, and the event dispatcher
:rtype: list
'''
self.partition.armAway(self.getMockedEventDispatcher())
zone = Zone('porch', [self.partition, self.light, self.audioSink])
zm = MockedZoneManager([zone])
eventInfo = EventInfo(zoneEvent, ITEMS[0], zone, zm,
self.getMockedEventDispatcher())
return [zone, zm, eventInfo]
PE.runUnitTest(TurnOffDevicesOnAlarmModeChangeTest)
action = AlertOnExternalDoorLeftOpen(0.1)
value = action.onAction(eventInfo)
self.assertTrue(value)
self.assertTrue(action.hasRunningTimer())
time.sleep(0.3) # wait for the production code timer
self.assertTrue("door" in AlertManager._lastEmailedSubject)
def testOnAction_aDoorWasOpenButClosedSoonAfter_returnsTrueAndTimerCancelled(
self):
ITEMS[0].setState(scope.OnOffType.ON)
eventInfo = EventInfo(ZoneEvent.CONTACT_OPEN, ITEMS[0], self.zone1,
None, self.getMockedEventDispatcher())
action = AlertOnExternalDoorLeftOpen()
value = action.onAction(eventInfo)
self.assertTrue(value)
self.assertTrue(action.hasRunningTimer())
# simulate door closed
ITEMS[0].setState(scope.OnOffType.OFF)
value = action.onAction(eventInfo)
self.assertTrue(value)
self.assertFalse(action.hasRunningTimer())
PE.runUnitTest(AlertOnExternalDoorLeftOpenTest)
TTS_MESSAGE = 'hello world'
class ChromeCastTest(unittest.TestCase):
def test_ctor(self):
cast = ChromeCast(PREFIX, SINK)
self.assertEqual(PREFIX, cast.getPrefix())
self.assertEqual(SINK, cast.getSinkName())
self.assertEqual(None, cast.getStreamUrl())
self.assertEqual(None, cast.getStreamName())
self.assertEqual(None, cast.getLastTtsMessage())
self.assertEqual(PREFIX + "Player", cast.getPlayerName())
self.assertEqual(PREFIX + "Volume", cast.getVolumeName())
self.assertEqual(PREFIX + "Idling", cast.getIdleItemName())
def testSetStream_validValues_returnsNormally(self):
cast = ChromeCast(PREFIX, SINK)
cast.setStream(STREAM_NAME, STREAM_URL)
self.assertEqual(STREAM_URL, cast.getStreamUrl())
self.assertEqual(STREAM_NAME, cast.getStreamName())
def testSetLastTtsMessage_validValues_returnsNormally(self):
cast = ChromeCast(PREFIX, SINK)
cast._setLastTtsMessage(TTS_MESSAGE)
self.assertEqual(TTS_MESSAGE, cast.getLastTtsMessage())
PE.runUnitTest(ChromeCastTest)
self.assertEqual([7, 0, 12, 0], list[0])
def testStringToTimeRangeLists_oneRangeWithDiffHourPartialMinutes_returnsExpected(
self):
list = time_utilities.stringToTimeRangeLists("7:10 - 12")
self.assertEqual(1, len(list))
self.assertEqual([7, 10, 12, 0], list[0])
def testStringToTimeRangeLists_oneRangeWithDiffHourMinutes_returnsExpected(
self):
list = time_utilities.stringToTimeRangeLists("7:10 - 12:30")
self.assertEqual(1, len(list))
self.assertEqual([7, 10, 12, 30], list[0])
def testStringToTimeRangeLists_wrapAroundHour_returnsExpected(self):
list = time_utilities.stringToTimeRangeLists("21 - 7")
self.assertEqual(1, len(list))
self.assertEqual([21, 0, 7, 0], list[0])
def testStringToTimeRangeLists_multipleRanges_returnsExpected(self):
list = time_utilities.stringToTimeRangeLists(
"7:10 - 8:30, 9, 13 - 15, 16-17:30")
self.assertEqual(4, len(list))
self.assertEqual([7, 10, 8, 30], list[0])
self.assertEqual([9, 0, 9, 59], list[1])
self.assertEqual([13, 0, 15, 0], list[2])
self.assertEqual([16, 0, 17, 30], list[3])
PE.runUnitTest(TimeUtilitiesTest)
def testProcessAlert_criticalAlert_returnsTrue(self):
alert = Alert.createCriticalAlert(SUBJECT)
result = AlertManager.processAlert(alert)
self.assertTrue(result)
casts = cast_manager.getAllCasts()
for cast in casts:
self.assertEqual(SUBJECT, cast.getLastTtsMessage())
def testProcessAlert_withinInterval_returnsFalse(self):
alert = Alert.createCriticalAlert(SUBJECT, None, [], MODULE, 1)
self.assertTrue(AlertManager.processAlert(alert))
# send alert would be ignored dued to interval threshold
self.assertFalse(AlertManager.processAlert(alert))
# but another alert with module would go through
self.assertTrue(AlertManager.processAlert(Alert.createCriticalAlert(SUBJECT)))
def testProcessAdminAlert_warningAlert_returnsTrue(self):
alert = Alert.createWarningAlert(SUBJECT)
result = AlertManager.processAdminAlert(alert)
self.assertTrue(result)
self.assertEqual(alert.getSubject(), AlertManager._lastEmailedSubject)
def testGetEmailAddresses_noParams_returnsNonEmptyList(self):
emails = AlertManager._getOwnerEmailAddresses()
self.assertTrue(len(emails) > 0)
PE.runUnitTest(AlertManagerTest)
scope.itemRegistry.add(self.motionSensorItem)
self.motionSensorItem.setState(scope.OnOffType.OFF)
self.motionSensor = MotionSensor(self.motionSensorItem)
self.events = MockedEventDispatcher(scope.itemRegistry)
def tearDown(self):
scope.itemRegistry.remove(self.motionSensorItem.getName())
def testIsOn_various_returnsExpected(self):
self.events.sendCommand(self.motionSensorItem.getName(), "ON")
self.assertTrue(self.motionSensor.isOn())
self.events.sendCommand(self.motionSensorItem.getName(), "OFF")
self.assertFalse(self.motionSensor.isOn())
def testIsOccupied_various_returnsExpected(self):
itemName = self.motionSensorItem.getName()
self.events.sendCommand(itemName, "ON")
self.motionSensor.onMotionSensorTurnedOn(self.events, itemName)
self.assertTrue(self.motionSensor.isOccupied())
self.events.sendCommand(self.motionSensorItem.getName(), "OFF")
self.assertTrue(self.motionSensor.isOccupied())
PE.runUnitTest(MotionSensorTest)
# Unit tests for zone_parser.py.
class ZoneParserTest(unittest.TestCase):
def testParse_scopeHasItems_returnsNonEmptyZoneList(self):
zoneManager = "mocked"
zones = ZoneParser().parse(scope.items, scope.itemRegistry,
zoneManager)
self.assertTrue(len(zones) > 0)
for z in zones:
self.assertTrue(len(z.getDevices()) > 0)
for d in z.getDevices():
self.assertEqual(zoneManager, d.getZoneManager())
self.assertTrue(
any(len(z.getDevicesByType(AstroSensor)) > 0 for z in zones))
self.assertTrue(any(
len(z.getDevicesByType(Dimmer)) > 0 for z in zones))
self.assertTrue(any(len(z.getDevicesByType(Fan)) > 0 for z in zones))
self.assertTrue(
any(len(z.getDevicesByType(IlluminanceSensor)) > 0 for z in zones))
self.assertTrue(any(len(z.getDevicesByType(Light)) > 0 for z in zones))
self.assertTrue(
any(len(z.getDevicesByType(MotionSensor)) > 0 for z in zones))
self.assertTrue(
any(len(z.getDevicesByType(AlarmPartition)) > 0 for z in zones))
PE.runUnitTest(ZoneParserTest)
class PlugTest(DeviceTest):
def setUp(self):
super(PlugTest, self).setUp()
self.plug = Plug(self.getItems()[0], self.getItems()[1])
def getItems(self, resetState = False):
if resetState:
ITEMS[0].setState(OnOffType.OFF)
ITEMS[1].setState(DecimalType(100))
return ITEMS
def testIsOn_notOn_returnsFalse(self):
self.assertFalse(self.plug.isOn())
def testTurnOn_withScopeEvents_returnsTrue(self):
self.plug.turnOn(self.getMockedEventDispatcher())
self.assertTrue(self.plug.isOn())
self.assertEqual(100, self.plug.getWattage())
def testTurnOff_withScopeEvents_returnsTrue(self):
ITEMS[0].setState(OnOffType.ON)
self.assertTrue(self.plug.isOn())
self.plug.turnOff(self.getMockedEventDispatcher())
self.assertFalse(self.plug.isOn())
PE.runUnitTest(PlugTest)
from aaa_modules.layout_model.device_test import DeviceTest
#from aaa_modules.layout_model.devices import illuminance_sensor
#reload(illuminance_sensor)
from aaa_modules.layout_model.devices.illuminance_sensor import IlluminanceSensor
from aaa_modules.platform_encapsulator import PlatformEncapsulator as PE
ITEMS = [NumberItem('IlluminanceSensorName')]
# Unit tests for illuminance_sensor.py.
class IlluminanceSensorTest(DeviceTest):
def setUp(self):
super(IlluminanceSensorTest, self).setUp()
self.illuminanceSensor = IlluminanceSensor(self.getItems()[0])
def getItems(self, resetState=False):
if resetState:
ITEMS[0].setState(DecimalType(0))
return ITEMS
def testGetIlluminanceLevel_noParams_returnsValidValue(self):
self.assertEqual(0, self.illuminanceSensor.getIlluminanceLevel())
ITEMS[0].setState(DecimalType(50))
self.assertEqual(50, self.illuminanceSensor.getIlluminanceLevel())
PE.runUnitTest(IlluminanceSensorTest)
return ITEMS
def testIsInAlarm_notInAlarm_returnsFalse(self):
self.assertFalse(self.alarmPartition.isInAlarm())
def testIsInAlarm_inAlarm_returnsTrue(self):
ITEMS[0].setState(scope.OnOffType.ON)
self.assertTrue(self.alarmPartition.isInAlarm())
def testArmAway_noParam_setCorrectValue(self):
self.alarmPartition.armAway(self.getMockedEventDispatcher())
self.assertEqual(AlarmPartition.STATE_ARM_AWAY,
self.alarmPartition.getArmMode())
def testArmStay_noParam_setCorrectValue(self):
self.alarmPartition.armStay(self.getMockedEventDispatcher())
self.assertEqual(AlarmPartition.STATE_ARM_STAY,
self.alarmPartition.getArmMode())
def testDisarm_noParam_setCorrectValue(self):
self.alarmPartition.disarm(self.getMockedEventDispatcher())
self.assertEqual(AlarmPartition.STATE_UNARMED,
self.alarmPartition.getArmMode())
PE.runUnitTest(AlarmPartitionTest)
def testOnAction_zoneDoesNotContainSensor_returnsFalse(self):
eventInfo = EventInfo(ZoneEvent.GAS_TRIGGER_STATE_CHANGED, ITEMS[0], Zone('innerZone'),
None, self.getMockedEventDispatcher())
value = self.action.onAction(eventInfo)
self.assertFalse(value)
def testOnAction_crossThreshold_returnsTrueAndSendAlert(self):
ITEMS[0].setState(scope.OnOffType.ON)
self.sendEventAndAssertAlertContainMessage('above normal level')
def testOnAction_noLongerTriggered_returnsTrueAndSendsInfoAlert(self):
# initially below threshold
ITEMS[0].setState(scope.OnOffType.ON)
self.sendEventAndAssertAlertContainMessage('above normal level')
# now back to normal
ITEMS[0].setState(scope.OnOffType.OFF)
self.sendEventAndAssertAlertContainMessage('back to normal')
def sendEventAndAssertAlertContainMessage(self, message):
AlertManager.reset()
eventInfo = EventInfo(ZoneEvent.GAS_TRIGGER_STATE_CHANGED, ITEMS[0], self.zone1,
None, self.getMockedEventDispatcher())
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertTrue(message in AlertManager._lastEmailedSubject)
PE.runUnitTest(AlertOnHighGasLevelTest)
def testTurnOn_lightWasOffWithinDimTimeRange_returnsExpected(self):
timeStruct = time.localtime()
hourOfDay = timeStruct[3]
dimLevel = 5
nextHour = 0 if hourOfDay == 23 else hourOfDay + 1 # 24-hour wrapping
timeRanges = "{}-{}".format(hourOfDay, nextHour)
self.dimmer = Dimmer(self.dimmerItem, 10, dimLevel, timeRanges)
self.dimmer.turnOn(MockedEventDispatcher(scope.itemRegistry))
self.assertTrue(self.dimmer.isOn())
self.assertEqual(dimLevel, self.dimmerItem.getState().intValue())
self.assertTrue(self.dimmer._isTimerActive())
def testTurnOn_lightWasAlreadyOn_timerIsRenewed(self):
self.dimmerItem.setState(PercentType(100))
self.dimmer.turnOn(MockedEventDispatcher(scope.itemRegistry))
self.assertTrue(self.dimmer.isOn())
self.assertTrue(self.dimmer._isTimerActive())
def testTurnOff_bothLightAndTimerOn_timerIsRenewed(self):
self.dimmerItem.setState(PercentType(0))
self.dimmer.turnOff(MockedEventDispatcher(scope.itemRegistry))
self.assertFalse(self.dimmer.isOn())
PE.runUnitTest(DimmerTest)
def testIsLunchTime_notLunchTime_returnsFalse(self):
dt = datetime.datetime(2020, 02, 8, 01, 00)
self.assertFalse(self.activity.isLunchTime(time.mktime(dt.timetuple())))
def testIsQuietTime_rightTime_returnsTrue(self):
dt = datetime.datetime(2020, 02, 8, 15, 00)
self.assertTrue(self.activity.isQuietTime(time.mktime(dt.timetuple())))
def testIsQuietTime_wrongTime_returnsFalse(self):
dt = datetime.datetime(2020, 02, 8, 10, 00)
self.assertFalse(self.activity.isQuietTime(time.mktime(dt.timetuple())))
def testIsDinnerTime_rightTime_returnsTrue(self):
dt = datetime.datetime(2020, 02, 8, 19, 00)
self.assertTrue(self.activity.isDinnerTime(time.mktime(dt.timetuple())))
def testIsDinnerTime_wrongTime_returnsFalse(self):
dt = datetime.datetime(2020, 02, 8, 10, 00)
self.assertFalse(self.activity.isDinnerTime(time.mktime(dt.timetuple())))
def testIsSleepTime_rightTime_returnsTrue(self):
dt = datetime.datetime(2020, 02, 8, 02, 00)
self.assertTrue(self.activity.isSleepTime(time.mktime(dt.timetuple())))
def testIsSleepTime_wrongTime_returnsFalse(self):
dt = datetime.datetime(2020, 02, 8, 10, 00)
self.assertFalse(self.activity.isSleepTime(time.mktime(dt.timetuple())))
PE.runUnitTest(ActivityTimesTest)
self.lightItem3.setState(scope.OnOffType.ON)
eventInfo = EventInfo(ZoneEvent.MOTION, ITEMS[0], self.zone2,
self.createMockedZoneManager(),
self.getMockedEventDispatcher())
returnVal = TurnOnSwitch().onAction(eventInfo)
self.assertFalse(returnVal)
self.assertFalse(self.zone2.isLightOn())
self.assertTrue(self.zone3.isLightOn())
def turnOn(self):
eventInfo = EventInfo(ZoneEvent.MOTION, ITEMS[0], self.zone1,
self.createMockedZoneManager(),
self.getMockedEventDispatcher())
return TurnOnSwitch().onAction(eventInfo)
# Helper method to set up the relationship between the provided zone and zone1.
def setUpNeighborRelationship(self, zone, type, neighborLightOn):
self.illuminanceSensorItem.setState(
DecimalType(ILLUMINANCE_THRESHOLD_IN_LUX - 1))
self.zone1 = self.zone1.addNeighbor(Neighbor(zone.getId(), type))
if neighborLightOn:
self.lightItem2.setState(scope.OnOffType.ON)
def createMockedZoneManager(self):
return MockedZoneManager([self.zone1, self.zone2, self.zone3])
PE.runUnitTest(TurnOnSwitchTest)
None, scope.events)
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertEqual('playStream', self.sink._getLastTestCommand())
def testOnAction_switchOnEventAndAudioSinkInNeighborZone_playsStreamAndReturnsTrue(
self):
zone1 = Zone('shower')
zone2 = Zone('washroom').addDevice(self.sink)
zone1 = zone1.addNeighbor(
Neighbor(zone2.getId(), NeighborType.OPEN_SPACE))
eventInfo = EventInfo(ZoneEvent.SWITCH_TURNED_ON, ITEMS[0], zone1,
MockedZoneManager([zone1, zone2]), scope.events)
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertEqual('playStream', self.sink._getLastTestCommand())
def testOnAction_switchOffEvent_pauseStreamAndReturnsTrue(self):
zone1 = Zone('shower').addDevice(self.sink)
eventInfo = EventInfo(ZoneEvent.SWITCH_TURNED_OFF, ITEMS[0], zone1,
None, scope.events)
value = self.action.onAction(eventInfo)
self.assertTrue(value)
self.assertEqual('pause', self.sink._getLastTestCommand())
PE.runUnitTest(PlayMusicDuringShowerTest)
def testRetrieveHourlyForecast_invalidCity_throwsException(self):
with self.assertRaises(ValueError) as cm:
EnvCanada.retrieveHourlyForecast('blah')
self.assertEqual("Can't map city name to URL for blah",
cm.exception.args[0])
def testRetrieveHourlyForecast_validCity_returnsForecast(self):
forecasts = EnvCanada.retrieveHourlyForecast('Ottawa')
self.assertTrue(len(forecasts) > 0)
for forecast in forecasts:
self.assertTrue(forecast.getForecastTime() >= 0)
self.assertTrue(len(forecast.getCondition()) > 0)
self.assertTrue(len(forecast.getPrecipationProbability()) > 0)
def testRetrieveHourlyForecast_validUrl_returnsForecast(self):
forecasts = EnvCanada.retrieveHourlyForecast(
'https://www.weather.gc.ca/forecast/hourly/on-118_metric_e.html',
24)
self.assertEqual(24, len(forecasts))
for forecast in forecasts:
self.assertTrue(forecast.getForecastTime() >= 0)
self.assertTrue(len(forecast.getCondition()) > 0)
self.assertTrue(len(forecast.getPrecipationProbability()) > 0)
PE.runUnitTest(EnvCanadaTest)
def testOnAction_doorClosedWithNoPresenceEvent_armAndReturnsTrue(self):
ITEMS[0].setState(scope.OnOffType.OFF) # close door
self.alarmPartition.disarm(self.getMockedEventDispatcher())
eventInfo = EventInfo(ZoneEvent.CONTACT_CLOSED, ITEMS[0],
self.zone1, self.mockZoneManager, self.getMockedEventDispatcher())
value = ArmAfterFrontDoorClosed(0.1).onAction(eventInfo)
self.assertTrue(value)
time.sleep(0.2)
self.assertTrue(self.alarmPartition.isArmedAway())
def testOnAction_doorClosedWithPresenceEvent_notArmedAndReturnsTrue(self):
ITEMS[0].setState(scope.OnOffType.OFF) # close door
self.alarmPartition.disarm(self.getMockedEventDispatcher())
eventInfo = EventInfo(ZoneEvent.CONTACT_CLOSED, ITEMS[0],
self.zone1, self.mockZoneManager, self.getMockedEventDispatcher())
value = ArmAfterFrontDoorClosed(0.1).onAction(eventInfo)
self.assertTrue(value)
time.sleep(0.1)
# simulate a motion event
self.internalMotionSensor._updateLastActivatedTimestamp()
time.sleep(0.1)
self.assertFalse(self.alarmPartition.isArmedAway())
PE.runUnitTest(ArmAfterFrontDoorClosedTest)
self.assertFalse(self.light.isLowIlluminance(-1))
def testIsLowIlluminance_currentIlluminanceAboveThreshold_returnsFalse(
self):
self.light = Light(self.lightItem, 10, 50)
self.assertFalse(self.light.isLowIlluminance(60))
def testIsLowIlluminance_currentIlluminanceBelowThreshold_returnsTrue(
self):
self.light = Light(self.lightItem, 10, 50)
self.assertTrue(self.light.isLowIlluminance(10))
def testTimerTurnedOff_validParams_switchIsOff(self):
zm = ZoneManager()
self.light = Light(self.lightItem, 0.004) # makes it 0.24 sec
self.light = self.light.setZoneManager(zm._createImmutableInstance())
zone = Zone('ff', [self.light])
zm.addZone(zone)
self.lightItem.setState(scope.OnOffType.ON)
self.light._startTimer(MockedEventDispatcher(scope.itemRegistry))
self.assertTrue(self.light._isTimerActive())
time.sleep(0.3)
self.assertFalse(self.light._isTimerActive())
self.assertFalse(self.light.isOn())
PE.runUnitTest(LightTest)
from aaa_modules.layout_model.devices.astro_sensor import AstroSensor
ITEMS = [StringItem('AstroSensorName')]
# Unit tests for astro_sensor.py.
class AstroSensorTest(DeviceTest):
def setUp(self):
super(AstroSensorTest, self).setUp()
self.astroSensor = AstroSensor(self.getItems()[0])
def getItems(self, resetState=False):
if resetState:
ITEMS[0].setState(StringType(AstroSensor.LIGHT_ON_TIMES[0]))
return ITEMS
def testIsLightOnTime_eveningTime_returnsTrue(self):
for value in AstroSensor.LIGHT_ON_TIMES:
ITEMS[0].setState(StringType(value))
self.assertTrue(self.astroSensor.isLightOnTime())
def testIsLightOnTime_dayTime_returnsFalse(self):
invalidValues = ["MORNING", "DAY", "AFTERNOON"]
for value in invalidValues:
ITEMS[0].setState(StringType(value))
self.assertFalse(self.astroSensor.isLightOnTime())
PE.runUnitTest(AstroSensorTest)