class TestVesync7ASwitch(object):
"""Test 7A outlet API."""
@pytest.fixture()
def api_mock(self, caplog):
"""Mock call_api() and initialize VeSync object."""
self.mock_api_call = patch.object(pyvesync_v2.helpers.Helpers,
'call_api')
self.mock_api = self.mock_api_call.start()
self.mock_api.create_autospect()
self.mock_api.return_value.ok = True
self.vesync_obj = VeSync('*****@*****.**', 'pass')
self.vesync_obj.enabled = True
self.vesync_obj.login = True
self.vesync_obj.tk = 'sample_tk'
self.vesync_obj.account_id = 'sample_actid'
caplog.set_level(logging.DEBUG)
yield
self.mock_api_call.stop()
def test_7aswitch_conf(self, api_mock):
"""Test inizialization of 7A outlet."""
self.mock_api.return_value = CORRECT_7A_LIST
devs = self.vesync_obj.get_devices()
assert len(devs) == 4
vswitch7a = devs[0][0]
assert isinstance(vswitch7a, VeSyncOutlet7A)
assert vswitch7a.device_name == "Name 7A Outlet"
assert vswitch7a.device_type == "wifi-switch-1.3"
assert vswitch7a.cid == "7A-CID"
assert vswitch7a.is_on
def test_7a_details(self, api_mock):
"""Test get_details() method for 7A outlet."""
self.mock_api.return_value = CORRECT_7A_DETAILS
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch7a.get_details()
dev_details = vswitch7a.details
assert vswitch7a.device_status == 'on'
assert type(dev_details) == dict
assert dev_details['active_time'] == 1
assert dev_details['energy'] == 1
assert vswitch7a.power == 1
assert vswitch7a.voltage == 1
def test_7a_no_devstatus(self, caplog, api_mock):
"""Test 7A outlet details response with no device status key."""
bad_7a_details = {
"deviceImg": "",
"activeTime": 1,
"energy": 1,
"power": "1A:1A",
"voltage": "1A:1A"
}
self.mock_api.return_value = (bad_7a_details, 200)
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch7a.get_details()
assert len(caplog.records) == 2
assert 'details' in caplog.text
def test_7a_no_details(self, caplog, api_mock):
"""Test 7A outlet details response with unknown keys."""
bad_7a_details = {"wrongdetails": "on"}
self.mock_api.return_value = (bad_7a_details, 200)
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch7a.get_details()
assert len(caplog.records) == 2
def test_7a_onoff(self, caplog, api_mock):
"""Test 7A outlet on/off methods."""
self.mock_api.return_value = ("response", 200)
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
on = vswitch7a.turn_on()
head = helpers.req_headers(self.vesync_obj)
self.mock_api.assert_called_with('/v1/wifi-switch-1.3/' +
vswitch7a.cid + '/status/on',
'put',
headers=head)
assert on
off = vswitch7a.turn_off()
self.mock_api.assert_called_with('/v1/wifi-switch-1.3/' +
vswitch7a.cid + '/status/off',
'put',
headers=head)
assert off
def test_7a_onoff_fail(self, api_mock):
"""Test 7A outlet on/off methods that fail."""
self.mock_api.return_value = ('response', 400)
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
assert not vswitch7a.turn_on()
assert not vswitch7a.turn_off()
def test_7a_weekly(self, api_mock):
"""Test 7A outlet weekly energy API call and energy dict."""
self.mock_api.return_value = ENERGY_HISTORY
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch7a.get_weekly_energy()
self.mock_api.assert_called_with(
'/v1/device/' + vswitch7a.cid + '/energy/week',
'get',
headers=helpers.req_headers(self.vesync_obj))
energy_dict = vswitch7a.energy['week']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
def test_7a_monthly(self, api_mock):
"""Test 7A outlet monthly energy API call and energy dict."""
self.mock_api.return_value = ENERGY_HISTORY
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch7a.get_monthly_energy()
self.mock_api.assert_called_with(
'/v1/device/' + vswitch7a.cid + '/energy/month',
'get',
headers=helpers.req_headers(self.vesync_obj))
energy_dict = vswitch7a.energy['month']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
def test_7a_yearly(self, api_mock):
"""Test 7A outlet yearly energy API call and energy dict."""
self.mock_api.return_value = ENERGY_HISTORY
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch7a.get_yearly_energy()
self.mock_api.assert_called_with(
'/v1/device/' + vswitch7a.cid + '/energy/year',
'get',
headers=helpers.req_headers(self.vesync_obj))
energy_dict = vswitch7a.energy['year']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
def test_history_fail(self, caplog, api_mock):
"""Test handling of energy update failure."""
bad_history = {"code": 1}
self.mock_api.return_value = (bad_history, 200)
vswitch7a = VeSyncOutlet7A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch7a.update_energy()
assert len(caplog.records) == 2
assert 'weekly' in caplog.text
caplog.clear()
vswitch7a.get_monthly_energy()
assert len(caplog.records) == 2
assert 'monthly' in caplog.text
caplog.clear()
vswitch7a.get_yearly_energy()
assert len(caplog.records) == 2
assert 'yearly' in caplog.text
class TestVesync15ASwitch:
"""Tests for VeSync 15A Outlets."""
@pytest.fixture()
def api_mock(self, caplog):
"""Instantiate VeSync object and mock call_api."""
self.mock_api_call = patch('pyvesync_v2.helpers.Helpers.call_api')
self.mock_api = self.mock_api_call.start()
self.mock_api.create_autospect()
self.mock_api.return_value.ok = True
self.vesync_obj = VeSync('*****@*****.**', 'pass')
self.vesync_obj.enabled = True
self.vesync_obj.login = True
self.vesync_obj.token = 'sample_tk'
self.vesync_obj.account_id = 'sample_actid'
caplog.set_level(logging.DEBUG)
yield
self.mock_api_call.stop()
def test_15aswitch_conf(self, api_mock):
"""Tests that 15A Outlet is instantiated properly."""
self.mock_api.return_value = CORRECT_15A_LIST
outlets = self.vesync_obj.get_devices()
outlets = outlets[0]
assert len(outlets) == 1
vswitch15a = outlets[0]
assert isinstance(vswitch15a, VeSyncOutlet15A)
assert vswitch15a.device_name == "Name 15A Outlet"
assert vswitch15a.device_type == "ESW15-USA"
assert vswitch15a.cid == "15A-CID"
assert vswitch15a.uuid == "UUID"
def test_15a_details(self, api_mock):
"""Test 15A get_details()."""
self.mock_api.return_value = CORRECT_15A_DETAILS
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch15a.get_details()
dev_details = vswitch15a.details
assert vswitch15a.device_status == 'on'
assert type(dev_details) == dict
assert dev_details['active_time'] == 1
assert dev_details['energy'] == 1
assert dev_details['power'] == '1'
assert dev_details['voltage'] == '1'
assert vswitch15a.power == 1
assert vswitch15a.voltage == 1
assert vswitch15a.active_time == 1
assert vswitch15a.energy_today == 1
def test_15a_details_fail(self, caplog, api_mock):
"""Test 15A get_details with Code>0."""
self.mock_api.return_value = BAD_15A_LIST
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch15a.get_details()
assert len(caplog.records) == 1
assert 'details' in caplog.text
def test_15a_no_details(self, caplog, api_mock):
"""Test 15A details return with no details and code=0."""
bad_15a_details = {"code": 0, "deviceStatus": "on"}
self.mock_api.return_value = (bad_15a_details, 200)
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch15a.get_details()
assert len(caplog.records) == 1
def test_15a_onoff(self, caplog, api_mock):
"""Test 15A Device On/Off Methods."""
self.mock_api.return_value = ({"code": 0}, 200)
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
head = helpers.req_headers(self.vesync_obj)
body = helpers.req_body(self.vesync_obj, 'devicestatus')
body['status'] = 'on'
body['uuid'] = vswitch15a.uuid
on = vswitch15a.turn_on()
self.mock_api.assert_called_with('/15a/v1/device/devicestatus',
'put',
headers=head,
json=body)
assert on
off = vswitch15a.turn_off()
body['status'] = 'off'
self.mock_api.assert_called_with('/15a/v1/device/devicestatus',
'put',
headers=head,
json=body)
assert off
def test_15a_onoff_fail(self, api_mock):
"""Test 15A On/Off Fail with Code>0."""
self.mock_api.return_value = ({"code": 1}, 400)
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
assert not vswitch15a.turn_on()
assert not vswitch15a.turn_off()
def test_15a_weekly(self, api_mock):
"""Test 15A get_weekly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch15a.get_weekly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_week')
body['uuid'] = vswitch15a.uuid
self.mock_api.assert_called_with('/15a/v1/device/energyweek',
'post',
headers=helpers.req_headers(
self.vesync_obj),
json=body)
energy_dict = vswitch15a.energy['week']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert vswitch15a.weekly_energy_total == 1
def test_15a_monthly(self, api_mock):
"""Test 15A get_monthly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch15a.get_monthly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_month')
body['uuid'] = vswitch15a.uuid
self.mock_api.assert_called_with('/15a/v1/device/energymonth',
'post',
headers=helpers.req_headers(
self.vesync_obj),
json=body)
energy_dict = vswitch15a.energy['month']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert vswitch15a.monthly_energy_total == 1
def test_15a_yearly(self, api_mock):
"""Test 15A get_yearly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch15a.get_yearly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_year')
body['uuid'] = vswitch15a.uuid
self.mock_api.assert_called_with('/15a/v1/device/energyyear',
'post',
headers=helpers.req_headers(
self.vesync_obj),
json=body)
energy_dict = vswitch15a.energy['year']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert vswitch15a.yearly_energy_total == 1
def test_history_fail(self, caplog, api_mock):
"""Test 15A energy failure."""
bad_history = {"code": 1}
self.mock_api.return_value = (bad_history, 200)
vswitch15a = VeSyncOutlet15A(DEV_LIST_DETAIL, self.vesync_obj)
vswitch15a.update_energy()
assert len(caplog.records) == 1
assert 'weekly' in caplog.text
caplog.clear()
vswitch15a.get_monthly_energy()
assert len(caplog.records) == 1
assert 'monthly' in caplog.text
caplog.clear()
vswitch15a.get_yearly_energy()
assert len(caplog.records) == 1
assert 'yearly' in caplog.text
class TestVesyncAirPurifier(object):
"""Air purifier tests."""
@pytest.fixture()
def api_mock(self, caplog):
"""Mock call_api and initialize VeSync object."""
self.mock_api_call = patch('pyvesync_v2.helpers.Helpers.call_api')
self.mock_api = self.mock_api_call.start()
self.mock_api.create_autospect()
self.mock_api.return_value.ok = True
self.vesync_obj = VeSync('*****@*****.**', 'pass')
self.vesync_obj.enabled = True
self.vesync_obj.login = True
self.vesync_obj.token = 'sample_tk'
self.vesync_obj.account_id = 'sample_actid'
caplog.set_level(logging.DEBUG)
yield
self.mock_api_call.stop()
def test_airpur_conf(self, api_mock):
"""Tests that 15A Outlet is instantiated properly."""
self.mock_api.return_value = CORRECT_LIST
fans = self.vesync_obj.get_devices()
fan = fans[2]
assert len(fan) == 1
fan = fan[0]
assert isinstance(fan, VeSyncAir131)
assert fan.device_name == "Name Air Purifier"
assert fan.device_type == "LV-PUR131S"
assert fan.cid == "AIRPUR-CID"
assert fan.uuid == "UUID"
def test_airpur_details(self, api_mock):
"""Test 15A get_details()."""
self.mock_api.return_value = CORRECT_DETAILS
fan = VeSyncAir131(DEV_LIST_DETAIL, self.vesync_obj)
fan.get_details()
dev_details = fan.details
assert fan.device_status == 'on'
assert type(dev_details) == dict
assert dev_details['active_time'] == 1
assert fan.filter_life == 100
assert dev_details['screen_status'] == 'on'
assert fan.mode == 'manual'
assert dev_details['level'] == 1
assert fan.fan_level == 1
assert dev_details['air_quality'] == 'excellent'
assert fan.air_quality == 'excellent'
def test_airpur_details_fail(self, caplog, api_mock):
"""Test Air Purifier get_details with Code>0."""
self.mock_api.return_value = BAD_LIST
fan = VeSyncAir131(DEV_LIST_DETAIL, self.vesync_obj)
fan.get_details()
assert len(caplog.records) == 1
assert 'details' in caplog.text
def test_airpur_onoff(self, caplog, api_mock):
"""Test Air Purifier Device On/Off Methods."""
self.mock_api.return_value = ({"code": 0}, 200)
fan = VeSyncAir131(DEV_LIST_DETAIL, self.vesync_obj)
head = helpers.req_headers(self.vesync_obj)
body = helpers.req_body(self.vesync_obj, 'devicestatus')
fan.device_status = 'off'
body['status'] = 'on'
body['uuid'] = fan.uuid
on = fan.turn_on()
self.mock_api.assert_called_with(
'/131airPurifier/v1/device/deviceStatus',
'put',
json=body,
headers=head)
call_args = self.mock_api.call_args_list[0][0]
assert call_args[0] == '/131airPurifier/v1/device/deviceStatus'
assert call_args[1] == 'put'
assert on
fan.device_status = 'on'
off = fan.turn_off()
body['status'] = 'off'
self.mock_api.assert_called_with(
'/131airPurifier/v1/device/deviceStatus',
'put',
json=body,
headers=head)
assert off
def test_airpur_onoff_fail(self, api_mock):
"""Test Air Purifier On/Off Fail with Code>0."""
self.mock_api.return_value = ({"code": 1}, 400)
vswitch15a = VeSyncAir131(DEV_LIST_DETAIL, self.vesync_obj)
assert not vswitch15a.turn_on()
assert not vswitch15a.turn_off()
def test_airpur_fanspeed(self, caplog, api_mock):
"""Test changing fan speed of."""
self.mock_api.return_value = ({'code': 0}, 200)
fan = VeSyncAir131(DEV_LIST_DETAIL, self.vesync_obj)
fan.details['level'] = 1
b = fan.change_fan_speed()
assert fan.fan_level == 2
b = fan.change_fan_speed()
assert fan.fan_level == 3
b = fan.change_fan_speed()
assert fan.fan_level == 1
assert b
b = fan.change_fan_speed(2)
assert b
assert fan.fan_level == 2
def test_mode_toggle(self, caplog, api_mock):
"""Test changing modes on air purifier."""
self.mock_api.return_value = ({'code': 0}, 200)
fan = VeSyncAir131(DEV_LIST_DETAIL, self.vesync_obj)
f = fan.auto_mode()
assert f
assert fan.mode == 'auto'
f = fan.manual_mode()
assert fan.mode == 'manual'
assert f
f = fan.sleep_mode()
assert fan.mode == 'sleep'
assert f
class TestVesyncWallSwitch(object):
@pytest.fixture()
def api_mock(self, caplog):
self.mock_api_call = patch('pyvesync_v2.helpers.Helpers.call_api')
self.mock_api = self.mock_api_call.start()
self.mock_api.create_autospect()
self.mock_api.return_value.ok = True
self.vesync_obj = VeSync('*****@*****.**', 'pass')
self.vesync_obj.enabled = True
self.vesync_obj.login = True
self.vesync_obj.token = 'sample_tk'
self.vesync_obj.account_id = 'sample_actid'
caplog.set_level(logging.DEBUG)
yield
self.mock_api_call.stop()
def test_ws_conf(self, api_mock):
"""Tests that Wall Switch is instantiated properly"""
self.mock_api.return_value = CORRECT_WS_LIST
devices = self.vesync_obj.get_devices()
switch = devices[1]
assert len(switch) == 1
wswitch = switch[0]
assert isinstance(wswitch, VeSyncWallSwitch)
assert wswitch.device_name == "Name Wall Switch"
assert wswitch.device_type == "ESWL01"
assert wswitch.cid == "WS-CID"
assert wswitch.uuid == "UUID"
def test_ws_details(self, api_mock):
"""Test WS get_details() """
self.mock_api.return_value = CORRECT_WS_DETAILS
wswitch = VeSyncWallSwitch(DEV_LIST_DETAIL, self.vesync_obj)
wswitch.get_details()
dev_details = wswitch.details
assert wswitch.device_status == 'on'
assert type(dev_details) == dict
assert dev_details['active_time'] == 1
assert wswitch.connection_status == 'online'
def test_ws_details_fail(self, caplog, api_mock):
"""Test WS get_details with Code>0"""
self.mock_api.return_value = BAD_LIST
vswitch15a = VeSyncWallSwitch(DEV_LIST_DETAIL, self.vesync_obj)
vswitch15a.get_details()
assert len(caplog.records) == 1
assert 'details' in caplog.text
def test_ws_onoff(self, caplog, api_mock):
"""Test 15A Device On/Off Methods"""
self.mock_api.return_value = ({"code": 0}, 200)
wswitch = VeSyncWallSwitch(DEV_LIST_DETAIL, self.vesync_obj)
head = helpers.req_headers(self.vesync_obj)
body = helpers.req_body(self.vesync_obj, 'devicestatus')
body['status'] = 'on'
body['uuid'] = wswitch.uuid
on = wswitch.turn_on()
self.mock_api.assert_called_with(
'/inwallswitch/v1/device/devicestatus',
'put',
headers=head,
json=body)
assert on
off = wswitch.turn_off()
body['status'] = 'off'
self.mock_api.assert_called_with(
'/inwallswitch/v1/device/devicestatus',
'put',
headers=head,
json=body)
assert off
def test_ws_onoff_fail(self, api_mock):
"""Test ws On/Off Fail with Code>0"""
self.mock_api.return_value = ({"code": 1}, 400)
vswitch15a = VeSyncWallSwitch(DEV_LIST_DETAIL, self.vesync_obj)
assert not vswitch15a.turn_on()
assert not vswitch15a.turn_off()
class TestVesyncOutdoorPlug:
"""Test class for outdoor outlet."""
@pytest.fixture()
def api_mock(self, caplog):
"""Mock call_api and initialize VeSync object."""
self.mock_api_call = patch('pyvesync_v2.helpers.Helpers.call_api')
self.mock_api = self.mock_api_call.start()
self.mock_api.create_autospec()
self.mock_api.return_value.ok = True
self.vesync_obj = VeSync('*****@*****.**', 'pass')
self.vesync_obj.enabled = True
self.vesync_obj.login = True
self.vesync_obj.token = 'sample_tk'
self.vesync_obj.account_id = 'sample_actid'
caplog.set_level(logging.DEBUG)
yield
self.mock_api_call.stop()
def test_outdoor_conf(self, api_mock):
"""Tests outdoor outlet is instantiated properly."""
self.mock_api.return_value = CORRECT_OUTDOOR_LIST
outlets = self.vesync_obj.get_devices()
outlets = outlets[0]
assert len(outlets) == 2
outdoor_outlet = outlets[0]
assert isinstance(outdoor_outlet, VeSyncOutdoorPlug)
assert outdoor_outlet.device_type == 'ESO15-TB'
assert outdoor_outlet.uuid == 'UUID'
def test_outdoor_details(self, api_mock):
"""Tests retrieving outdoor outlet details."""
self.mock_api.return_value = CORRECT_OUTDOOR_DETAILS
outdoor_outlet = VeSyncOutdoorPlug(DEV_LIST_DETAIL, self.vesync_obj)
outdoor_outlet.get_details()
dev_details = outdoor_outlet.details
assert outdoor_outlet.device_status == 'on'
assert isinstance(outdoor_outlet, VeSyncOutdoorPlug)
assert dev_details['active_time'] == 1
def test_outdoor_details_fail(self, caplog, api_mock):
"""Test outdoor outlet get_details response."""
self.mock_api.return_value = BAD_OUTDOOR_LIST
outdoor_outlet = VeSyncOutdoorPlug(DEV_LIST_DETAIL, self.vesync_obj)
outdoor_outlet.get_details()
assert len(caplog.records) == 1
assert 'details' in caplog.text
def test_outdoor_outlet_onoff(self, caplog, api_mock):
"""Test Outdoor Outlet Device On/Off Methods."""
self.mock_api.return_value = ({"code": 0}, 200)
outdoor_outlet = VeSyncOutdoorPlug(DEV_LIST_DETAIL, self.vesync_obj)
head = helpers.req_headers(self.vesync_obj)
body = helpers.req_body(self.vesync_obj, 'devicestatus')
body['status'] = 'on'
body['uuid'] = outdoor_outlet.uuid
body['switchNo'] = outdoor_outlet.sub_device_no
on = outdoor_outlet.turn_on()
self.mock_api.assert_called_with(
'/outdoorsocket15a/v1/device/devicestatus',
'put',
headers=head,
json=body)
assert on
off = outdoor_outlet.turn_off()
body['status'] = 'off'
self.mock_api.assert_called_with(
'/outdoorsocket15a/v1/device/devicestatus',
'put',
headers=head,
json=body)
assert off
def test_outdoor_outlet_onoff_fail(self, api_mock):
"""Test outdoor outlet On/Off Fail with Code>0."""
self.mock_api.return_value = ({"code": 1}, 400)
outdoor_outlet = VeSyncOutdoorPlug(DEV_LIST_DETAIL, self.vesync_obj)
assert not outdoor_outlet.turn_on()
assert not outdoor_outlet.turn_off()
def test_outdoor_outlet_weekly(self, api_mock):
"""Test outdoor outlet get_weekly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
outdoor_outlet = VeSyncOutdoorPlug(DEV_LIST_DETAIL, self.vesync_obj)
outdoor_outlet.get_weekly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_week')
body['uuid'] = outdoor_outlet.uuid
self.mock_api.assert_called_with(
'/outdoorsocket15a/v1/device/energyweek',
'post',
headers=helpers.req_headers(self.vesync_obj),
json=body)
energy_dict = outdoor_outlet.energy['week']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert outdoor_outlet.weekly_energy_total == 1
def test_outdoor_outlet_monthly(self, api_mock):
"""Test outdoor outlet get_monthly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
outdoor_outlet = VeSyncOutdoorPlug(DEV_LIST_DETAIL, self.vesync_obj)
outdoor_outlet.get_monthly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_month')
body['uuid'] = outdoor_outlet.uuid
self.mock_api.assert_called_with(
'/outdoorsocket15a/v1/device/energymonth',
'post',
headers=helpers.req_headers(self.vesync_obj),
json=body)
energy_dict = outdoor_outlet.energy['month']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert outdoor_outlet.monthly_energy_total == 1
def test_outdoor_outlet_yearly(self, api_mock):
"""Test outdoor outlet get_yearly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
outdoor_outlet = VeSyncOutdoorPlug(DEV_LIST_DETAIL, self.vesync_obj)
outdoor_outlet.get_yearly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_year')
body['uuid'] = outdoor_outlet.uuid
self.mock_api.assert_called_with(
'/outdoorsocket15a/v1/device/energyyear',
'post',
headers=helpers.req_headers(self.vesync_obj),
json=body)
energy_dict = outdoor_outlet.energy['year']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert outdoor_outlet.yearly_energy_total == 1
def test_history_fail(self, caplog, api_mock):
"""Test outdoor outlet energy failure."""
bad_history = {"code": 1}
self.mock_api.return_value = (bad_history, 200)
outdoor_outlet = VeSyncOutdoorPlug(DEV_LIST_DETAIL, self.vesync_obj)
outdoor_outlet.update_energy()
assert len(caplog.records) == 1
assert 'weekly' in caplog.text
caplog.clear()
outdoor_outlet.get_monthly_energy()
assert len(caplog.records) == 1
assert 'monthly' in caplog.text
caplog.clear()
outdoor_outlet.get_yearly_energy()
assert len(caplog.records) == 1
assert 'yearly' in caplog.text
class TestVesync10ASwitch(object):
"""Test class for 10A outlets."""
@pytest.fixture()
def api_mock(self, caplog):
"""Mock call_api() method and initialize VeSync object."""
self.mock_api_call = patch('pyvesync_v2.helpers.Helpers.call_api')
self.mock_api = self.mock_api_call.start()
self.mock_api.create_autospect()
self.mock_api.return_value.ok = True
self.vesync_obj = VeSync('*****@*****.**', 'pass')
self.vesync_obj.enabled = True
self.vesync_obj.login = True
self.vesync_obj.token = 'sample_tk'
self.vesync_obj.account_id = 'sample_actid'
caplog.set_level(logging.DEBUG)
yield
self.mock_api_call.stop()
@pytest.mark.parametrize('mock_return, devtype',
[(CORRECT_10AEU_LIST, 'ESW01-EU'),
(CORRECT_10AUS_LIST, 'ESW03-USA')])
def test_10a_conf(self, mock_return, devtype, api_mock):
"""Tests that 10A US & EU Outlet is instantiated properly."""
self.mock_api.return_value = mock_return
outlets = self.vesync_obj.get_devices()
outlets = outlets[0]
assert len(outlets) == 1
outlet = outlets[0]
assert isinstance(outlet, VeSyncOutlet10A)
assert outlet.device_name == "Name 10A Outlet"
assert outlet.device_type == devtype
assert outlet.cid == "10A-CID"
assert outlet.uuid == "UUID"
def test_10a_details(self, api_mock):
"""Test 10A get_details()."""
self.mock_api.return_value = CORRECT_10A_DETAILS
outlet = VeSyncOutlet10A(DEV_LIST_DETAIL_US, self.vesync_obj)
outlet.get_details()
dev_details = outlet.details
assert outlet.device_status == 'on'
assert type(dev_details) == dict
assert dev_details['active_time'] == 1
assert dev_details['energy'] == 1
assert dev_details['power'] == '1'
assert dev_details['voltage'] == '1'
assert outlet.power == 1
assert outlet.voltage == 1
def test_10a_details_fail(self, caplog, api_mock):
"""Test 10A get_details with Code>0."""
self.mock_api.return_value = BAD_10A_LIST
out = VeSyncOutlet10A(DEV_LIST_DETAIL_EU, self.vesync_obj)
out.get_details()
assert len(caplog.records) == 1
assert 'details' in caplog.text
def test_10a_onoff(self, caplog, api_mock):
"""Test 10A Device On/Off Methods."""
self.mock_api.return_value = ({"code": 0}, 200)
out = VeSyncOutlet10A(DEV_LIST_DETAIL_EU, self.vesync_obj)
head = helpers.req_headers(self.vesync_obj)
body = helpers.req_body(self.vesync_obj, 'devicestatus')
body['status'] = 'on'
body['uuid'] = out.uuid
on = out.turn_on()
self.mock_api.assert_called_with('/10a/v1/device/devicestatus',
'put',
headers=head,
json=body)
assert on
off = out.turn_off()
body['status'] = 'off'
self.mock_api.assert_called_with('/10a/v1/device/devicestatus',
'put',
headers=head,
json=body)
assert off
def test_10a_onoff_fail(self, api_mock):
"""Test 10A On/Off Fail with Code>0."""
self.mock_api.return_value = ({"code": 1}, 400)
out = VeSyncOutlet10A(DEV_LIST_DETAIL_US, self.vesync_obj)
assert not out.turn_on()
assert not out.turn_off()
def test_10a_weekly(self, api_mock):
"""Test 10A get_weekly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
out = VeSyncOutlet10A(DEV_LIST_DETAIL_EU, self.vesync_obj)
out.get_weekly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_week')
body['uuid'] = out.uuid
self.mock_api.assert_called_with('/10a/v1/device/energyweek',
'post',
headers=helpers.req_headers(
self.vesync_obj),
json=body)
energy_dict = out.energy['week']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert out.weekly_energy_total == 1
def test_10a_monthly(self, api_mock):
"""Test 10A get_monthly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
out = VeSyncOutlet10A(DEV_LIST_DETAIL_EU, self.vesync_obj)
out.get_monthly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_month')
body['uuid'] = out.uuid
self.mock_api.assert_called_with('/10a/v1/device/energymonth',
'post',
headers=helpers.req_headers(
self.vesync_obj),
json=body)
energy_dict = out.energy['month']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert out.monthly_energy_total == 1
def test_10a_yearly(self, api_mock):
"""Test 10A get_yearly_energy."""
self.mock_api.return_value = ENERGY_HISTORY
out = VeSyncOutlet10A(DEV_LIST_DETAIL_US, self.vesync_obj)
out.get_yearly_energy()
body = helpers.req_body(self.vesync_obj, 'energy_year')
body['uuid'] = out.uuid
self.mock_api.assert_called_with('/10a/v1/device/energyyear',
'post',
headers=helpers.req_headers(
self.vesync_obj),
json=body)
energy_dict = out.energy['year']
assert energy_dict['energy_consumption_of_today'] == 1
assert energy_dict['cost_per_kwh'] == 1
assert energy_dict['max_energy'] == 1
assert energy_dict['total_energy'] == 1
assert energy_dict['data'] == [1, 1]
assert out.yearly_energy_total == 1
def test_history_fail(self, caplog, api_mock):
"""Test 15A energy failure."""
bad_history = {"code": 1}
self.mock_api.return_value = (bad_history, 200)
out = VeSyncOutlet10A(DEV_LIST_DETAIL_US, self.vesync_obj)
out.update_energy()
assert len(caplog.records) == 1
assert 'weekly' in caplog.text
caplog.clear()
out.get_monthly_energy()
assert len(caplog.records) == 1
assert 'monthly' in caplog.text
caplog.clear()
out.get_yearly_energy()
assert len(caplog.records) == 1
assert 'yearly' in caplog.text
class TestVeSyncBulbESL100:
"""Tests for VeSync dimmable bulb."""
@pytest.fixture()
def api_mock(self, caplog):
"""Initilize the mock VeSync class and patch call_api."""
self.mock_api_call = patch('pyvesync_v2.helpers.Helpers.call_api')
self.mock_api = self.mock_api_call.start()
self.mock_api.create_autospect()
self.mock_api.return_value.ok = True
self.vesync_obj = VeSync('*****@*****.**', 'pass')
self.vesync_obj.enabled = True
self.vesync_obj.login = True
self.vesync_obj.token = 'sample_tk'
self.vesync_obj.account_id = 'sample_actid'
caplog.set_level(logging.DEBUG)
yield
self.mock_api_call.stop()
def test_esl100_conf(self, api_mock):
"""Tests that Wall Switch is instantiated properly."""
self.mock_api.return_value = DEV_LIST
devices = self.vesync_obj.get_devices()
bulbs = devices[3]
assert len(bulbs) == 1
bulb = bulbs[0]
assert isinstance(bulb, VeSyncBulbESL100)
assert bulb.device_name == "Etekcity Soft White Bulb"
assert bulb.device_type == "ESL100"
assert bulb.cid == "ESL100-CID"
assert bulb.uuid == "UUID"
def test_esl100_details(self, api_mock):
"""Test WS get_details()."""
self.mock_api.return_value = DEVICE_DETAILS
bulb = VeSyncBulbESL100(DEV_LIST_DETAIL, self.vesync_obj)
bulb.get_details()
dev_details = bulb.details
assert bulb.device_status == 'on'
assert isinstance(dev_details, dict)
assert bulb.connection_status == 'online'
def test_esl100_no_details(self, caplog, api_mock):
"""Test no device details for disconnected bulb."""
self.mock_api.return_value = ({'code': 5}, 200)
bulb = VeSyncBulbESL100(DEV_LIST_DETAIL, self.vesync_obj)
bulb.update()
assert len(caplog.records) == 2
def test_esl100_onoff(self, caplog, api_mock):
"""Test power toggle for ESL100 bulb."""
self.mock_api.return_value = ({'code': 0}, 200)
bulb = VeSyncBulbESL100(DEV_LIST_DETAIL, self.vesync_obj)
assert bulb.turn_off()
assert bulb.turn_on()
def test_brightness(self, api_mock):
self.mock_api.return_value = ({'code': 0}, 200)
bulb = VeSyncBulbESL100(DEV_LIST_DETAIL, self.vesync_obj)
assert bulb.set_brightness(50)
def test_invalid_brightness(self, caplog, api_mock):
bulb = VeSyncBulbESL100(DEV_LIST_DETAIL, self.vesync_obj)
assert not bulb.set_brightness(5000)
def test_features(self, api_mock):
bulb = VeSyncBulbESL100(DEV_LIST_DETAIL, self.vesync_obj)
assert bulb.dimmable_feature
assert not bulb.color_temp_feature
assert not bulb.rgb_shift_feature