def test_thermostat_has_fan(self):
device_list = []
response_dict = {}
_json_file = open('{}/api_responses/sensi_thermostat.json'.format(os.path.dirname(__file__)))
device_list.append(json.load(_json_file))
_json_file.close()
response_dict["data"] = device_list
thermostat = get_devices_from_response_dict(response_dict, device_types.THERMOSTAT)[0]
self.assertTrue(thermostat.has_fan())
device_list = []
response_dict = {}
_json_file = open('{}/api_responses/ecobee_thermostat.json'.format(os.path.dirname(__file__)))
device_list.append(json.load(_json_file))
_json_file.close()
response_dict["data"] = device_list
thermostat = get_devices_from_response_dict(response_dict, device_types.THERMOSTAT)[0]
self.assertTrue(thermostat.has_fan())
device_list = []
response_dict = {}
_json_file = open('{}/api_responses/nest.json'.format(os.path.dirname(__file__)))
device_list.append(json.load(_json_file))
_json_file.close()
response_dict["data"] = device_list
thermostat = get_devices_from_response_dict(response_dict, device_types.THERMOSTAT)[0]
self.assertFalse(thermostat.has_fan())
device_list = []
response_dict = {}
_json_file = open('{}/api_responses/go_control_thermostat.json'.format(os.path.dirname(__file__)))
device_list.append(json.load(_json_file))
_json_file.close()
response_dict["data"] = device_list
thermostat = get_devices_from_response_dict(response_dict, device_types.THERMOSTAT)[0]
self.assertTrue(thermostat.has_fan())
def test_switch_groups_are_created_correctly(self):
all_devices = os.listdir('{}/api_responses/groups/'.format(
os.path.dirname(__file__)))
device_list = []
for json_file in all_devices:
if os.path.isfile('{}/api_responses/groups/{}'.format(
os.path.dirname(__file__), json_file)):
_json_file = open('{}/api_responses/groups/{}'.format(
os.path.dirname(__file__), json_file))
device_list.append(json.load(_json_file))
_json_file.close()
JSON_DATA["data"] = device_list
all_groups = get_devices_from_response_dict(JSON_DATA,
device_types.GROUP)
self.assertEqual(3, len(all_groups))
device_list = []
response_dict = {}
_json_file = open('{}/api_responses/groups/switch_group.json'.format(
os.path.dirname(__file__)))
device_list.append(json.load(_json_file))
_json_file.close()
response_dict["data"] = device_list
groups = get_devices_from_response_dict(response_dict,
device_types.GROUP)
self.assertEqual(1, len(groups))
self.assertTrue(isinstance(groups[0], WinkBinarySwitchGroup))
def test_should_convert_humidity_to_percentage(self):
with open('{}/api_responses/wink_relay_sensor.json'.format(
os.path.dirname(__file__))) as relay_file:
response_dict = json.load(relay_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
self.assertEqual(devices[0].humidity_percentage(), 69)
def test_gocontrol_motion_sensor_should_be_identified(self):
response = ApiResponseJSONLoader('motion_sensor_gocontrol.json').load()
devices = get_devices_from_response_dict(
response, DEVICE_ID_KEYS[device_types.SENSOR_POD])
self.assertEqual(2, len(devices))
self.assertIsInstance(devices[1], WinkMotionSensor)
self.assertIsInstance(devices[0], WinkTemperatureSensor)
def test_ge_switch_should_be_identified(self):
response = ApiResponseJSONLoader(
'light_switch_ge_jasco_z_wave.json').load()
devices = get_devices_from_response_dict(
response, DEVICE_ID_KEYS[device_types.BINARY_SWITCH])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkBinarySwitch)
def test_pubnub_key_and_channel_should_be_none(self):
with open('{}/api_responses/lock.json'.format(os.path.dirname(__file__))) as lock_file:
response_dict = json.load(lock_file)
device = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.LOCK])[0]
self.assertIsNone(device.pubnub_key)
self.assertIsNone(device.pubnub_channel)
def test_cloud_clock_json_parses_into_the_correct_objects(self):
with open('{}/api_responses/nimbus.json'.format(
os.path.dirname(__file__))) as nimbus_file:
response_dict = json.load(nimbus_file)
response_dict = {"data": [response_dict]}
devices = get_devices_from_response_dict(response_dict,
device_types.CLOUD_CLOCK)
self.assertEqual(len(devices), 8)
cloud_clock = devices[0]
self.assertTrue(isinstance(devices[0], WinkCloudClock))
self.assertTrue(isinstance(devices[1], WinkCloudClockDial))
self.assertTrue(isinstance(devices[2], WinkCloudClockDial))
self.assertTrue(isinstance(devices[3], WinkCloudClockDial))
self.assertTrue(isinstance(devices[4], WinkCloudClockDial))
self.assertTrue(isinstance(devices[5], WinkCloudClockAlarm))
self.assertTrue(isinstance(devices[6], WinkCloudClockAlarm))
self.assertTrue(isinstance(devices[7], WinkCloudClockAlarm))
self.assertEqual(devices[1].parent, cloud_clock)
self.assertEqual(devices[2].parent, cloud_clock)
self.assertEqual(devices[3].parent, cloud_clock)
self.assertEqual(devices[4].parent, cloud_clock)
self.assertEqual(devices[5].parent, cloud_clock)
self.assertEqual(devices[6].parent, cloud_clock)
self.assertEqual(devices[7].parent, cloud_clock)
def test_firmware_version_is_not_none(self):
devices = get_devices_from_response_dict(self.response_dict, device_types.HUB)
for device in devices:
if device.manufacturer_device_model() == "philips":
continue
else:
self.assertIsNotNone(device.firmware_version())
def test_all_devices_manufacturer_device_id_state_is_valid(self):
devices = get_devices_from_response_dict(
self.response_dict, device_types.ALL_SUPPORTED_DEVICES)
skip_types = [
WinkKey, WinkPowerStrip, WinkPowerStripOutlet,
WinkPorkfolioBalanceSensor, WinkPorkfolioNose, WinkSiren,
WinkEggtray, WinkRemote, WinkButton, WinkAirConditioner,
WinkPropaneTank
]
skip_manufactuer_device_models = [
"linear_wadwaz_1", "linear_wapirz_1", "aeon_labs_dsb45_zwus",
"wink_hub", "wink_hub2", "sylvania_sylvania_ct", "ge_bulb",
"quirky_ge_spotter", "schlage_zwave_lock",
"home_decorators_home_decorators_fan", "sylvania_sylvania_rgbw",
"somfy_bali", "wink_relay_sensor", "wink_project_one",
"kidde_smoke_alarm", "wink_relay_switch", "leaksmart_valve",
"home_decorators_home_decorators_light_bulb"
]
skip_names = [
"GoControl Thermostat", "GE Zwave Switch", "New Shortcut",
"Test robot"
]
for device in devices:
if device.name() in skip_names:
self.assertIsNone(device.manufacturer_device_id())
elif device.manufacturer_device_model(
) in skip_manufactuer_device_models:
self.assertIsNone(device.manufacturer_device_id())
elif type(device) in skip_types:
self.assertIsNone(device.manufacturer_device_id())
else:
self.assertIsNotNone(device.manufacturer_device_id())
def test_should_handle_power_strip_response(self):
with open('{}/api_responses/power_strip.json'.format(os.path.dirname(__file__))) as powerstrip_file:
response_dict = json.load(powerstrip_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.POWER_STRIP])
self.assertEqual(2, len(devices))
self.assertIsInstance(devices[0], WinkPowerStripOutlet)
self.assertIsInstance(devices[1], WinkPowerStripOutlet)
def test_should_handle_porkfolio_response(self):
with open('{}/api_responses/porkfolio.json'.format(os.path.dirname(__file__))) as porkfolio_file:
response_dict = json.load(porkfolio_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.PIGGY_BANK])
self.assertEqual(2, len(devices))
self.assertIsInstance(devices[0], WinkCurrencySensor)
self.assertIsInstance(devices[1], WinkPorkfolioNose)
def test_unit_is_usd(self):
devices = get_devices_from_response_dict(self.response_dict,
device_types.PIGGY_BANK)
self.assertEqual(len(devices), 2)
for device in devices:
if isinstance(device, WinkPorkfolioBalanceSensor):
self.assertEqual(device.unit(), "USD")
def test_gocontrol_motion_sensor_should_be_identified(self):
response = ApiResponseJSONLoader('motion_sensor_gocontrol.json').load()
devices = get_devices_from_response_dict(response,
DEVICE_ID_KEYS[
device_types.SENSOR_POD])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkSensorPod)
def test_all_devices_battery_is_valid(self):
devices = get_devices_from_response_dict(
self.response_dict, device_types.ALL_SUPPORTED_DEVICES)
skip_types = [
WinkFan, WinkGeZwaveFan, WinkPorkfolioBalanceSensor,
WinkPorkfolioNose, WinkBinarySwitch, WinkHub, WinkLightBulb,
WinkThermostat, WinkKey, WinkPowerStrip, WinkPowerStripOutlet,
WinkRemote, WinkShade, WinkSprinkler, WinkButton, WinkGang,
WinkCanaryCamera, WinkAirConditioner, WinkScene, WinkRobot,
WinkWaterHeater
]
for device in devices:
if device.manufacturer_device_model() == "leaksmart_valve":
self.assertIsNotNone(device.battery_level())
elif type(device) in skip_types:
self.assertIsNone(device.battery_level())
elif device.manufacturer_device_model() == "wink_relay_sensor":
self.assertIsNone(device.battery_level())
elif device.device_manufacturer() == "dropcam":
self.assertIsNone(device.battery_level())
elif device.model_name() == "Nest Cam":
self.assertIsNone(device.battery_level())
elif device._last_reading.get('external_power'):
self.assertIsNone(device.battery_level())
else:
self.assertIsNotNone(device.battery_level())
def test_should_handle_binary_switch_response(self):
with open('{}/api_responses/binary_switch.json'.format(
os.path.dirname(__file__))) as binary_switch_file:
response_dict = json.load(binary_switch_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.BINARY_SWITCH])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkBinarySwitch)
def test_current_min_set_point(self):
with open('{}/api_responses/sensi.json'.format(os.path.dirname(__file__))) as thermostat_file:
response_dict = json.load(thermostat_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.THERMOSTAT])
thermostat = devices[0]
""" :type thermostat: pywink.devices.standard.WinkThermostat """
self.assertEqual(22.22222222222222, thermostat.current_min_set_point())
def test_device_id_should_be_number(self):
with open('{}/api_responses/smoke_detector.json'.format(
os.path.dirname(__file__))) as smoke_detector_file:
response_dict = json.load(smoke_detector_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.SMOKE_DETECTOR])
device_id = devices[0].device_id()
self.assertRegex(device_id, "^[0-9]{4,6}")
def test_objectprefix_should_be_correct(self):
with open('{}/api_responses/porkfolio.json'.format(os.path.dirname(__file__))) as porkfolio_file:
response_dict = json.load(porkfolio_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.PIGGY_BANK])
objectprefix = devices[0].objectprefix
self.assertRegex(objectprefix, "piggy_bank")
objectprefix = devices[1].objectprefix
self.assertRegex(objectprefix, "piggy_bank")
def test_objectprefix_should_be_correct(self):
with open('{}/api_responses/smoke_detector.json'.format(os.path.dirname(__file__))) as smoke_detector_file:
response_dict = json.load(smoke_detector_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SMOKE_DETECTOR])
objectprefix = devices[0].objectprefix
self.assertRegex(objectprefix, "smoke_detectors")
objectprefix = devices[1].objectprefix
self.assertRegex(objectprefix, "smoke_detectors")
def test_should_be_cool_only_for_current_hvac_mode(self):
with open('{}/api_responses/sensi.json'.format(os.path.dirname(__file__))) as thermostat_file:
response_dict = json.load(thermostat_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.THERMOSTAT])
thermostat = devices[0]
""" :type thermostat: pywink.devices.standard.WinkThermostat """
self.assertEqual('cool_only', thermostat.current_hvac_mode())
def test_should_handle_siren_response(self):
with open('{}/api_responses/siren.json'.format(
os.path.dirname(__file__))) as siren_file:
response_dict = json.load(siren_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.SIREN])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkSiren)
def test_should_handle_garage_door_opener_response(self):
with open('{}/api_responses/garage_door.json'.format(
os.path.dirname(__file__))) as garage_door_file:
response_dict = json.load(garage_door_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.GARAGE_DOOR])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkGarageDoor)
def test_fan_timer_range(self):
fan = get_devices_from_response_dict(self.response_dict,
device_types.FAN)[0]
has_timer_range = fan.fan_timer_range()
self.assertEqual(len(has_timer_range), 2)
times = [0, 65535]
for time in has_timer_range:
self.assertTrue(time in times)
def test_fan_directions(self):
fan = get_devices_from_response_dict(self.response_dict,
device_types.FAN)[0]
has_directions = fan.fan_directions()
self.assertEqual(len(has_directions), 2)
directions = ['forward', 'reverse']
for direction in has_directions:
self.assertTrue(direction in directions)
def test_should_be_false_if_response_doesnt_contains_aux_capabilities(self):
with open('{}/api_responses/nest.json'.format(os.path.dirname(__file__))) as thermostat_file:
response_dict = json.load(thermostat_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.THERMOSTAT])
thermostat = devices[0]
""" :type thermostat: pywink.devices.standard.WinkThermostat """
self.assertFalse('aux' in thermostat.hvac_modes())
def test_should_handle_sensor_pod_response(self):
with open('{}/api_responses/binary_sensor.json'.format(
os.path.dirname(__file__))) as binary_sensor_file:
response_dict = json.load(binary_sensor_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkSensorPod)
def test_should_be_true_if_thermostat_fan_is_on(self):
with open('{}/api_responses/sensi.json'.format(os.path.dirname(__file__))) as thermostat_file:
response_dict = json.load(thermostat_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.THERMOSTAT])
thermostat = devices[0]
""" :type thermostat: pywink.devices.standard.WinkThermostat """
self.assertTrue(thermostat.fan_on())
def test_should_handle_egg_tray_response(self):
with open('{}/api_responses/eggtray.json'.format(
os.path.dirname(__file__))) as eggtray_file:
response_dict = json.load(eggtray_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.EGG_TRAY])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkEggTray)
def test_state_should_be_false(self):
with open('{}/api_responses/ge_zwave_switch.json'.format(os.path.dirname(__file__))) as binary_switch_file:
response_dict = json.load(binary_switch_file)
response_dict = {"data": [response_dict]}
devices = get_devices_from_response_dict(response_dict, device_types.BINARY_SWITCH)
switch = devices[0]
self.assertFalse(switch.state())
def test_should_show_powered_state_as_false_if_device_is_disconnected(
self):
with open('{}/api_responses/power_strip.json'.format(
os.path.dirname(__file__))) as powerstrip_file:
response_dict = json.load(powerstrip_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.POWER_STRIP])
self.assertFalse(devices[0].state())
def test_should_handle_light_bulb_response(self):
with open('{}/api_responses/light_bulb.json'.format(
os.path.dirname(__file__))) as light_file:
response_dict = json.load(light_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.LIGHT_BULB])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkBulb)
def test_should_hub_response(self):
with open('{}/api_responses/v1_hub.json'.format(
os.path.dirname(__file__))) as hub_file:
response_dict = json.load(hub_file)
devices = get_devices_from_response_dict(
response_dict, DEVICE_ID_KEYS[device_types.HUB])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkHub)
def test_fan_speeds(self):
fan = get_devices_from_response_dict(self.response_dict,
device_types.FAN)[0]
has_speeds = fan.fan_speeds()
self.assertEqual(len(has_speeds), 3)
speeds = ['low', 'medium', 'high']
for speed in has_speeds:
self.assertTrue(speed in speeds)
def test_unit_is_valid(self):
devices = get_devices_from_response_dict(self.response_dict,
device_types.SENSOR_POD)
for device in devices:
if device.unit_type() == "boolean":
self.assertIsNone(device.unit())
else:
self.assertIsNotNone(device.unit())
def test_available_should_be_true(self):
with open('{}/api_responses/scene.json'.format(os.path.dirname(__file__))) as scene_file:
response_dict = json.load(scene_file)
response_dict = {"data": [response_dict]}
devices = get_devices_from_response_dict(response_dict, device_types.SCENE)
scene = devices[0]
self.assertTrue(scene.available())
def test_buttons_press_is_false(self):
devices = get_devices_from_response_dict(self.response_dict,
device_types.REMOTE)
remote = devices[0]
self.assertFalse(remote.button_on_pressed())
self.assertFalse(remote.button_off_pressed())
self.assertFalse(remote.button_up_pressed())
self.assertFalse(remote.button_down_pressed())
def test_battery_level_should_return_float(self):
with open('{}/api_responses/quirky_spotter_2.json'.format(os.path.dirname(__file__))) as spotter_file:
response_dict = json.load(spotter_file)
sensors = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
for sensor in sensors:
self.assertEqual(sensor.battery_level, 0.86)
def test_current_humidifier_mode(self):
# sensi.json been faked to add in the humidifier_mode field for testing.
with open('{}/api_responses/sensi.json'.format(os.path.dirname(__file__))) as thermostat_file:
response_dict = json.load(thermostat_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.THERMOSTAT])
thermostat = devices[0]
""" :type thermostat: pywink.devices.standard.WinkThermostat """
self.assertEqual('auto', thermostat.current_humidifier_mode())
def test_brightness_should_have_correct_value(self):
with open('{}/api_responses/quirky_spotter.json'.format(os.path.dirname(__file__))) as spotter_file:
response_dict = json.load(spotter_file)
sensors = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
""":type : list of WinkBrightnessSensor"""
brightness_sensor = [sensor for sensor in sensors if sensor.capability() is WinkBrightnessSensor.CAPABILITY][0]
expected_brightness = 1
self.assertEquals(expected_brightness, brightness_sensor.brightness_percentage())
def test_eggs(self):
devices = get_devices_from_response_dict(self.response_dict,
device_types.EGGTRAY)
for device in devices:
for egg in device.eggs():
try:
val = float(egg)
except ValueError:
self.fail("test_eggs raised ValueError unexpectedly.")
def test_device_id_should_start_with_a_number(self):
with open('{}/api_responses/quirky_spotter.json'.format(os.path.dirname(__file__))) as spotter_file:
response_dict = json.load(spotter_file)
sensors = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
for sensor in sensors:
device_id = sensor.device_id()
self.assertRegex(device_id, "^[0-9]{4,6}")
def test_device_id_should_be_number(self):
with open('{}/api_responses/porkfolio.json'.format(os.path.dirname(__file__))) as porkfolio_file:
response_dict = json.load(porkfolio_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.PIGGY_BANK])
device_id = devices[0].device_id()
self.assertRegex(device_id, "^[0-9]{4,6}")
device_id = devices[1].device_id()
self.assertRegex(device_id, "^[0-9]{4,6}")
def test_ac_modes(self):
device_list = []
response_dict = {}
_json_file = open('{}/api_responses/quirky_aros.json'.format(os.path.dirname(__file__)))
device_list.append(json.load(_json_file))
_json_file.close()
response_dict["data"] = device_list
ac = get_devices_from_response_dict(response_dict, device_types.AIR_CONDITIONER)[0]
self.assertEqual(ac.modes(), ["auto_eco", "cool_only", "fan_only"])
def test_should_be_true_if_thermostat_has_detected_occupancy(self):
# sensi.json been faked to add in the occupied field for testing.
with open('{}/api_responses/sensi.json'.format(os.path.dirname(__file__))) as thermostat_file:
response_dict = json.load(thermostat_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.THERMOSTAT])
thermostat = devices[0]
""" :type thermostat: pywink.devices.standard.WinkThermostat """
self.assertTrue(thermostat.occupied())
def test_ac_max_set_point(self):
device_list = []
response_dict = {}
_json_file = open('{}/api_responses/quirky_aros.json'.format(os.path.dirname(__file__)))
device_list.append(json.load(_json_file))
_json_file.close()
response_dict["data"] = device_list
ac = get_devices_from_response_dict(response_dict, device_types.AIR_CONDITIONER)[0]
self.assertEqual(ac.current_max_set_point(), 20.0)
def test_should_handle_relay_response(self):
with open('{}/api_responses/wink_relay_sensor.json'.format(os.path.dirname(__file__))) as relay_file:
response_dict = json.load(relay_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
self.assertEqual(4, len(devices))
self.assertIsInstance(devices[0], WinkHumiditySensor)
self.assertIsInstance(devices[1], WinkTemperatureSensor)
self.assertIsInstance(devices[2], WinkPresenceSensor)
self.assertIsInstance(devices[3], WinkProximitySensor)
def test_schedule_enabled(self):
device_list = []
response_dict = {}
_json_file = open('{}/api_responses/quirky_aros.json'.format(os.path.dirname(__file__)))
device_list.append(json.load(_json_file))
_json_file.close()
response_dict["data"] = device_list
ac = get_devices_from_response_dict(response_dict, device_types.AIR_CONDITIONER)[0]
self.assertTrue(ac.schedule_enabled())
def test_temperature_should_have_correct_value(self):
with open('{}/api_responses/quirky_spotter.json'.format(os.path.dirname(__file__))) as spotter_file:
response_dict = json.load(spotter_file)
sensors = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
""":type : list of WinkTemperatureSensor"""
temp_sensor = [sensor for sensor in sensors if sensor.capability() is WinkTemperatureSensor.CAPABILITY][0]
expected_temperature = 5
self.assertEquals(expected_temperature, temp_sensor.temperature_float())
def test_vibration_should_have_correct_value(self):
with open('{}/api_responses/quirky_spotter.json'.format(os.path.dirname(__file__))) as spotter_file:
response_dict = json.load(spotter_file)
sensors = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
""":type : list of WinkVibrationPresenceSensor"""
vibration_sensor = [sensor for sensor in sensors if sensor.capability() is WinkVibrationPresenceSensor.CAPABILITY][0]
expected_vibrartion_presence = False
self.assertEquals(expected_vibrartion_presence, vibration_sensor.vibration_boolean())
def test_should_be_false_if_response_does_not_contain_rgb_capabilities(self):
with open('{}/api_responses/rgb_absent.json'.format(os.path.dirname(__file__))) as light_file:
response_dict = json.load(light_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.LIGHT_BULB])
bulb = devices[0]
""" :type bulb: pywink.devices.standard.WinkBulb """
supports_rgb = bulb.supports_rgb()
self.assertFalse(supports_rgb,
msg="Expected rgb to be un-supported")
def test_should_be_true_if_response_contains_xy_capabilities(self):
with open('{}/api_responses/xy_present.json'.format(os.path.dirname(__file__))) as light_file:
response_dict = json.load(light_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.LIGHT_BULB])
bulb = devices[0]
""" :type bulb: pywink.devices.standard.WinkBulb """
supports_xy = bulb.supports_xy_color()
self.assertTrue(supports_xy,
msg="Expected xy to be supported")
def test_current_smart_temperature(self):
# This result is only present on ecobee thermostats, the sensi.json has
# been faked to add in the smart_temperature field for testing.
with open('{}/api_responses/sensi.json'.format(os.path.dirname(__file__))) as thermostat_file:
response_dict = json.load(thermostat_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.THERMOSTAT])
thermostat = devices[0]
""" :type thermostat: pywink.devices.standard.WinkThermostat """
self.assertEqual(20.555555555555557, thermostat.current_smart_temperature())
def test_should_handle_smoke_detector_response(self):
with open('{}/api_responses/smoke_detector.json'.format(os.path.dirname(__file__))) as smoke_detector_file:
response_dict = json.load(smoke_detector_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SMOKE_DETECTOR])
self.assertEqual(2, len(devices))
smoke = devices[0]
co = devices[1]
self.assertIsInstance(smoke, WinkSmokeDetector)
self.assertIsInstance(co, WinkCoDetector)
self.assertFalse(smoke.smoke_detected_boolean())
self.assertTrue(co.co_detected_boolean())
def test_humidity_is_percentage_after_update(self):
with open('{}/api_responses/quirky_spotter.json'.format(os.path.dirname(__file__))) as spotter_file:
response_dict = json.load(spotter_file)
sensors = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
""":type : list of WinkHumiditySensor"""
humidity_sensor = [sensor for sensor in sensors if sensor.capability() is WinkHumiditySensor.CAPABILITY][0]
with open('{}/api_responses/quirky_spotter_pubnub.json'.format(os.path.dirname(__file__))) as spotter_file:
update_response_dict = json.load(spotter_file)
humidity_sensor.pubnub_update(update_response_dict)
expected_humidity = 24
self.assertEquals(expected_humidity, humidity_sensor.humidity_percentage())
def test_should_handle_siren_response(self):
with open('{}/api_responses/siren.json'.format(os.path.dirname(__file__))) as siren_file:
response_dict = json.load(siren_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SIREN])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkSiren)
def test_should_handle_egg_tray_response(self):
with open('{}/api_responses/eggtray.json'.format(os.path.dirname(__file__))) as eggtray_file:
response_dict = json.load(eggtray_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.EGG_TRAY])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkEggTray)
def test_should_show_powered_state_as_false_if_device_is_disconnected(self):
with open('{}/api_responses/power_strip.json'.format(os.path.dirname(__file__))) as powerstrip_file:
response_dict = json.load(powerstrip_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.POWER_STRIP])
self.assertFalse(devices[0].state())
def test_should_handle_garage_door_opener_response(self):
with open('{}/api_responses/garage_door.json'.format(os.path.dirname(__file__))) as garage_door_file:
response_dict = json.load(garage_door_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.GARAGE_DOOR])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkGarageDoor)
def test_alternative_quirky_spotter_api_response_should_create_one_primary_sensor_and_five_subsensors(self):
with open('{}/api_responses/quirky_spotter_2.json'.format(os.path.dirname(__file__))) as spotter_file:
response_dict = json.load(spotter_file)
sensors = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.SENSOR_POD])
self.assertEquals(1 + 5, len(sensors))
def test_should_handle_light_bulb_response(self):
with open('{}/api_responses/light_bulb.json'.format(os.path.dirname(__file__))) as light_file:
response_dict = json.load(light_file)
devices = get_devices_from_response_dict(response_dict, DEVICE_ID_KEYS[device_types.LIGHT_BULB])
self.assertEqual(1, len(devices))
self.assertIsInstance(devices[0], WinkBulb)
