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)