async def test_403_during_remote_query(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.get_data(TEST_VIN_3_G2))
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_3_G2,
"_": str(int(time.time()))
},
)
await server_js_response(server,
VEHICLE_STATUS_G2,
path=sc.API_VEHICLE_STATUS)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(server, ERROR_403, path=sc.API_CONDITION)
await server_js_response(server,
VALIDATE_SESSION_FAIL,
path=sc.API_VALIDATE_SESSION)
await server_js_response(server,
LOGIN_MULTI_REGISTERED,
path=sc.API_LOGIN)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_3_G2,
"_": str(int(time.time()))
},
)
await server_js_response(server,
CONDITION_G2,
path=sc.API_CONDITION)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(server, LOCATE_G2, path=sc.API_LOCATE)
result = await task
assert result[sc.VEHICLE_STATUS][sc.BATTERY_VOLTAGE]
async def test_vehicle_attributes(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
assert controller.vin_to_name(
TEST_VIN_1_G1) == FAKE_CAR_DATA_1["nickname"]
assert controller.vin_to_name(
TEST_VIN_2_EV) == FAKE_CAR_DATA_2["nickname"]
assert controller.vin_to_name(
TEST_VIN_3_G2) == FAKE_CAR_DATA_3["nickname"]
assert controller.vin_to_name(
TEST_VIN_4_SAFETY_PLUS) == FAKE_CAR_DATA_4["nickname"]
assert controller.vin_to_name(
TEST_VIN_5_G1_SECURITY) == FAKE_CAR_DATA_5["nickname"]
assert controller.get_api_gen(
TEST_VIN_1_G1) == sc.FEATURE_G1_TELEMATICS
assert controller.get_api_gen(
TEST_VIN_2_EV) == sc.FEATURE_G2_TELEMATICS
assert controller.get_api_gen(
TEST_VIN_3_G2) == sc.FEATURE_G2_TELEMATICS
assert controller.get_api_gen(
TEST_VIN_4_SAFETY_PLUS) == sc.FEATURE_G2_TELEMATICS
assert controller.get_api_gen(
TEST_VIN_5_G1_SECURITY) == sc.FEATURE_G1_TELEMATICS
assert not controller.get_safety_status(TEST_VIN_1_G1)
assert controller.get_safety_status(TEST_VIN_2_EV)
assert controller.get_safety_status(TEST_VIN_3_G2)
assert controller.get_safety_status(TEST_VIN_4_SAFETY_PLUS)
assert controller.get_safety_status(TEST_VIN_5_G1_SECURITY)
assert not controller.get_ev_status(TEST_VIN_1_G1)
assert controller.get_ev_status(TEST_VIN_2_EV)
assert not controller.get_ev_status(TEST_VIN_3_G2)
assert not controller.get_ev_status(TEST_VIN_4_SAFETY_PLUS)
assert not controller.get_ev_status(TEST_VIN_5_G1_SECURITY)
assert not controller.get_remote_status(TEST_VIN_1_G1)
assert controller.get_remote_status(TEST_VIN_2_EV)
assert controller.get_remote_status(TEST_VIN_3_G2)
assert not controller.get_remote_status(TEST_VIN_4_SAFETY_PLUS)
assert controller.get_remote_status(TEST_VIN_5_G1_SECURITY)
assert not controller.get_res_status(TEST_VIN_1_G1)
assert not controller.get_res_status(TEST_VIN_2_EV)
assert controller.get_res_status(TEST_VIN_3_G2)
assert not controller.get_res_status(TEST_VIN_4_SAFETY_PLUS)
assert not controller.get_res_status(TEST_VIN_5_G1_SECURITY)
async def test_test_login_success(http_redirect, ssl_certificate):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
http_redirect.add_server(sc.MOBILE_API_SERVER, 443, server.port)
controller = subarulink.Controller(
http_redirect.session, TEST_USERNAME, TEST_PASSWORD, TEST_DEVICE_ID, TEST_PIN, TEST_DEVICE_NAME,
)
task = asyncio.create_task(controller.connect(test_login=True))
await server_js_response(server, LOGIN_SINGLE_REGISTERED, path=sc.API_LOGIN)
await server_js_response(
server, REFRESH_VEHICLES_SINGLE, path=sc.API_REFRESH_VEHICLES, query={"_": str(int(time.time()))},
)
assert await task is True
async def test_test_pin_success(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.test_pin())
await server_js_response(server, VALIDATE_SESSION_SUCCESS, path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_2,
path=sc.API_SELECT_VEHICLE,
query={"vin": TEST_VIN_2_EV, "_": str(int(time.time()))},
)
await server_js_response(server, VEHICLE_STATUS_EV, path=sc.API_G2_LOCATE_UPDATE)
assert await task
async def test_switch_vehicle_fail(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.lights(TEST_VIN_2_EV))
await server_js_response(server, VALIDATE_SESSION_SUCCESS, path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
ERROR_VIN_NOT_FOUND,
path=sc.API_SELECT_VEHICLE,
query={"vin": TEST_VIN_2_EV, "_": str(int(time.time()))},
)
with pytest.raises(SubaruException):
await task
async def test_connect_single_car(http_redirect, ssl_certificate):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
http_redirect.add_server(sc.MOBILE_API_SERVER, 443, server.port)
controller = subarulink.Controller(
http_redirect.session, TEST_USERNAME, TEST_PASSWORD, TEST_DEVICE_ID, TEST_PIN, TEST_DEVICE_NAME,
)
task = asyncio.create_task(controller.connect())
await server_js_response(server, LOGIN_SINGLE_REGISTERED, path=sc.API_LOGIN)
await server_js_response(
server, REFRESH_VEHICLES_SINGLE, path=sc.API_REFRESH_VEHICLES, query={"_": str(int(time.time()))},
)
response = await task
assert response is True
assert controller.get_vehicles() == [TEST_VIN_1_G1]
assert controller.get_ev_status(TEST_VIN_1_G1) is False
async def test_connect_incomplete_credentials(http_redirect, ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
http_redirect.add_server(sc.MOBILE_API_SERVER[sc.COUNTRY_USA], 443,
server.port)
controller = subarulink.Controller(
http_redirect.session,
TEST_USERNAME,
None,
TEST_DEVICE_ID,
TEST_PIN,
TEST_DEVICE_NAME,
)
task = asyncio.create_task(controller.connect())
with pytest.raises(subarulink.SubaruException):
await task
async def test_remote_cmds_unsupported(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
cmd_list = [
{
"command": controller.horn(TEST_VIN_4_SAFETY_PLUS),
"path": sc.API_HORN_LIGHTS
},
{
"command": controller.horn_stop(TEST_VIN_4_SAFETY_PLUS),
"path": sc.API_HORN_LIGHTS_STOP
},
{
"command": controller.lights(TEST_VIN_4_SAFETY_PLUS),
"path": sc.API_LIGHTS
},
{
"command": controller.lights_stop(TEST_VIN_4_SAFETY_PLUS),
"path": sc.API_LIGHTS_STOP
},
{
"command": controller.lock(TEST_VIN_4_SAFETY_PLUS),
"path": sc.API_LOCK
},
{
"command": controller.unlock(TEST_VIN_4_SAFETY_PLUS),
"path": sc.API_UNLOCK
},
{
"command": controller.charge_start(TEST_VIN_4_SAFETY_PLUS),
"path": sc.API_EV_CHARGE_NOW
},
{
"command": controller.remote_stop(TEST_VIN_4_SAFETY_PLUS),
"path": sc.API_G2_REMOTE_ENGINE_STOP
},
]
for cmd in cmd_list:
task = asyncio.create_task(cmd["command"])
with pytest.raises(VehicleNotSupported):
assert not await task
async def test_interval_functions(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
INVALID_NEW_INTERVAL = 25
VALID_NEW_INTERVAL = 500
assert controller.get_update_interval() == sc.DEFAULT_UPDATE_INTERVAL
controller.set_update_interval(INVALID_NEW_INTERVAL)
assert controller.get_update_interval() == sc.DEFAULT_UPDATE_INTERVAL
controller.set_update_interval(VALID_NEW_INTERVAL)
assert controller.get_update_interval() == VALID_NEW_INTERVAL
assert controller.get_fetch_interval() == sc.DEFAULT_FETCH_INTERVAL
controller.set_fetch_interval(INVALID_NEW_INTERVAL)
assert controller.get_fetch_interval() == sc.DEFAULT_FETCH_INTERVAL
controller.set_fetch_interval(VALID_NEW_INTERVAL)
assert controller.get_fetch_interval() == VALID_NEW_INTERVAL
async def test_test_pin_fail(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.test_pin())
await server_js_response(server, VALIDATE_SESSION_SUCCESS, path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_2,
path=sc.API_SELECT_VEHICLE,
query={"vin": TEST_VIN_2_EV, "_": str(int(time.time()))},
)
await server_js_response(server, REMOTE_CMD_INVALID_PIN, path=sc.API_G2_LOCATE_UPDATE)
with pytest.raises(subarulink.InvalidPIN):
await task
assert not controller.update_saved_pin(TEST_PIN)
assert controller.update_saved_pin("0000")
async def test_test_login_fail(http_redirect, ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
http_redirect.add_server(sc.MOBILE_API_SERVER[sc.COUNTRY_USA], 443,
server.port)
controller = subarulink.Controller(
http_redirect.session,
TEST_USERNAME,
TEST_PASSWORD,
TEST_DEVICE_ID,
TEST_PIN,
TEST_DEVICE_NAME,
)
for fail_msg in LOGIN_ERRORS:
task = asyncio.create_task(controller.connect(test_login=True))
await server_js_response(server, fail_msg, path=sc.API_LOGIN)
with pytest.raises(subarulink.SubaruException):
await task
async def test_remote_start_no_args(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.remote_start(TEST_VIN_3_G2))
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_3_G2,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
GET_CLIMATE_SETTINGS_G2,
path=sc.API_G2_FETCH_CLIMATE_SETTINGS,
)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
REMOTE_SERVICE_EXECUTE,
path=sc.API_G2_REMOTE_ENGINE_START,
)
await server_js_response(server,
REMOTE_SERVICE_STATUS_STARTED,
path=sc.API_REMOTE_SVC_STATUS)
await server_js_response(
server,
REMOTE_SERVICE_STATUS_FINISHED_SUCCESS,
path=sc.API_REMOTE_SVC_STATUS,
)
assert await task
async def test_switch_vehicle_success(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.lights(TEST_VIN_2_EV))
await server_js_response(server, VALIDATE_SESSION_SUCCESS, path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_2,
path=sc.API_SELECT_VEHICLE,
query={"vin": TEST_VIN_2_EV, "_": str(int(time.time()))},
)
await server_js_response(server, REMOTE_SERVICE_EXECUTE, path=sc.API_LIGHTS)
await server_js_response(server, REMOTE_SERVICE_STATUS_STARTED, path=sc.API_REMOTE_SVC_STATUS)
await server_js_response(
server, REMOTE_SERVICE_STATUS_FINISHED_SUCCESS, path=sc.API_REMOTE_SVC_STATUS,
)
assert await task
async def test_validate_climate_settings(http_redirect, ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
form_data = {
sc.REAR_AC: None,
sc.MODE: None,
sc.FAN_SPEED: None,
sc.TEMP: "100",
sc.REAR_DEFROST: None,
sc.HEAT_SEAT_LEFT: None,
sc.HEAT_SEAT_RIGHT: None,
sc.RECIRCULATE: None,
sc.RUNTIME: None,
sc.START_CONFIG: None,
}
task = asyncio.create_task(
controller.save_climate_settings(TEST_VIN_3_G2, form_data))
assert not await task
async def test_handle_404(http_redirect, ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
http_redirect.add_server(sc.MOBILE_API_SERVER[sc.COUNTRY_USA], 443,
server.port)
controller = subarulink.Controller(
http_redirect.session,
TEST_USERNAME,
TEST_PASSWORD,
TEST_DEVICE_ID,
TEST_PIN,
TEST_DEVICE_NAME,
)
task = asyncio.create_task(controller.connect())
await server_js_response(server,
LOGIN_INVALID_PASSWORD,
path=sc.API_LOGIN,
status=404)
with pytest.raises(subarulink.SubaruException):
await task
async def test_expired_session(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.horn(TEST_VIN_3_G2))
await server_js_response(server,
VALIDATE_SESSION_FAIL,
path=sc.API_VALIDATE_SESSION)
await server_js_response(server,
LOGIN_MULTI_REGISTERED,
path=sc.API_LOGIN)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_3_G2,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
REMOTE_SERVICE_EXECUTE,
path=sc.API_HORN_LIGHTS,
)
await server_js_response(
server,
REMOTE_SERVICE_STATUS_STARTED,
path=sc.API_REMOTE_SVC_STATUS,
)
await server_js_response(
server,
REMOTE_SERVICE_STATUS_FINISHED_SUCCESS,
path=sc.API_REMOTE_SVC_STATUS,
)
assert await task
async def test_get_vehicle_status_g2_security_plus(http_redirect,
ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
VALID_EXTERNAL_TEMP = "22.0"
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.get_data(TEST_VIN_3_G2))
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_3_G2,
"_": str(int(time.time()))
},
)
await server_js_response(server,
VEHICLE_STATUS_G2,
path=sc.API_VEHICLE_STATUS)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
# Manually set EXTERNAL_TEMP to good value
controller._vehicles[TEST_VIN_3_G2]["status"][
sc.EXTERNAL_TEMP] = VALID_EXTERNAL_TEMP
# This condition below includes a known erroneous EXTERNAL_TEMP, which should be discarded
await server_js_response(server, CONDITION_G2, path=sc.API_CONDITION)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(server, LOCATE_G2, path=sc.API_LOCATE)
status = (await task)["status"]
assert status[sc.LOCATION_VALID]
# Verify erroneous EXTERNAL TEMP was discarded
assert status[sc.EXTERNAL_TEMP] == VALID_EXTERNAL_TEMP
assert_vehicle_status(status, VEHICLE_STATUS_G2)
async def test_save_climate_settings(http_redirect, ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
form_data = {
sc.REAR_AC: "false",
sc.MODE: "AUTO",
sc.FAN_SPEED: "AUTO",
sc.TEMP: "71",
sc.REAR_DEFROST: sc.REAR_DEFROST_OFF,
sc.HEAT_SEAT_LEFT: "OFF",
sc.HEAT_SEAT_RIGHT: "OFF",
sc.RECIRCULATE: "outsideAir",
sc.RUNTIME: "10",
sc.START_CONFIG:
"start_Climate_Control_only_allow_key_in_ignition",
}
task = asyncio.create_task(
controller.save_climate_settings(TEST_VIN_2_EV, form_data))
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_2,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_2_EV,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
SAVE_CLIMATE_SETTINGS,
path=sc.API_G2_SAVE_CLIMATE_SETTINGS,
)
assert await task
async def test_get_vehicle_status_safety_plus(http_redirect, ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.get_data(TEST_VIN_4_SAFETY_PLUS))
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_4,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_4_SAFETY_PLUS,
"_": str(int(time.time()))
},
)
await server_js_response(server,
VEHICLE_STATUS_G2,
path=sc.API_VEHICLE_STATUS)
status = (await task)["status"]
assert_vehicle_status(status, VEHICLE_STATUS_G2)
async def test_get_vehicle_status_no_subscription(http_redirect,
ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.get_data(TEST_VIN_1_G1))
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_1,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_1_G1,
"_": str(int(time.time()))
},
)
await server_js_response(server,
VEHICLE_STATUS_G2_NO_TIRE_PRESSURE,
path=sc.API_VEHICLE_STATUS)
await task
async def test_connect_device_registration(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
http_redirect.add_server(sc.MOBILE_API_SERVER, 443, server.port)
http_redirect.add_server(sc.WEB_API_SERVER, 443, server.port)
controller = subarulink.Controller(
http_redirect.session, TEST_USERNAME, TEST_PASSWORD, TEST_DEVICE_ID, TEST_PIN, TEST_DEVICE_NAME,
)
task = asyncio.create_task(controller.connect())
await server_js_response(server, LOGIN_SINGLE_NOT_REGISTERED, path=sc.API_LOGIN)
await server_js_response(
server, REFRESH_VEHICLES_SINGLE, path=sc.API_REFRESH_VEHICLES, query={"_": str(int(time.time()))},
)
await server_js_response(server, True, path=sc.WEB_API_LOGIN)
await server_js_response(server, True, path=sc.WEB_API_AUTHORIZE_DEVICE)
await server_js_response(server, True, path=sc.WEB_API_NAME_DEVICE)
await server_js_response(server, LOGIN_SINGLE_NOT_REGISTERED, path=sc.API_LOGIN)
await server_js_response(server, LOGIN_SINGLE_NOT_REGISTERED, path=sc.API_LOGIN)
await server_js_response(server, LOGIN_SINGLE_REGISTERED, path=sc.API_LOGIN)
response = await task
assert response
async def test_403_during_remote_command(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.update(TEST_VIN_2_EV))
await server_js_response(server, VALIDATE_SESSION_SUCCESS, path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_2,
path=sc.API_SELECT_VEHICLE,
query={"vin": TEST_VIN_2_EV, "_": str(int(time.time()))},
)
await server_js_response(
server, ERROR_403, path=sc.API_G2_LOCATE_UPDATE,
)
# 403 Handling and reattempt
await server_js_response(server, VALIDATE_SESSION_FAIL, path=sc.API_VALIDATE_SESSION)
await server_js_response(server, LOGIN_MULTI_REGISTERED, path=sc.API_LOGIN)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={"vin": TEST_VIN_2_EV, "_": str(int(time.time()))},
)
await server_js_response(
server, VEHICLE_STATUS_EXECUTE, path=sc.API_G2_LOCATE_UPDATE,
)
# Back to normal
await server_js_response(server, VEHICLE_STATUS_STARTED, path=sc.API_G2_LOCATE_STATUS)
await server_js_response(
server, VEHICLE_STATUS_FINISHED_SUCCESS, path=sc.API_G2_LOCATE_STATUS,
)
assert await task
async def test_remote_cmd_timeout_g1(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(
controller.lights(TEST_VIN_5_G1_SECURITY))
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
LOCATE_G1_EXECUTE,
path=sc.API_LIGHTS,
)
for _ in range(0, 20):
await server_js_response(server,
LOCATE_G1_STARTED,
path=sc.API_G1_HORN_LIGHTS_STATUS)
with pytest.raises(RemoteServiceFailure):
assert not await task
async def test_get_vehicle_status_no_tire_pressure(http_redirect,
ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
task = asyncio.create_task(controller.get_data(TEST_VIN_4_SAFETY_PLUS))
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_4,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_4_SAFETY_PLUS,
"_": str(int(time.time()))
},
)
# Manually set Tire Pressures to good value
good_data = VEHICLE_STATUS_G2["data"]
controller._vehicles[TEST_VIN_4_SAFETY_PLUS]["status"][
sc.TIRE_PRESSURE_FL] = good_data[sc.VS_TIRE_PRESSURE_FL]
controller._vehicles[TEST_VIN_4_SAFETY_PLUS]["status"][
sc.TIRE_PRESSURE_FR] = good_data[sc.VS_TIRE_PRESSURE_FR]
controller._vehicles[TEST_VIN_4_SAFETY_PLUS]["status"][
sc.TIRE_PRESSURE_RL] = good_data[sc.VS_TIRE_PRESSURE_RL]
controller._vehicles[TEST_VIN_4_SAFETY_PLUS]["status"][
sc.TIRE_PRESSURE_RR] = good_data[sc.VS_TIRE_PRESSURE_RR]
# Provide no tire pressures, controller should ignore and keep previous
await server_js_response(server,
VEHICLE_STATUS_G2_NO_TIRE_PRESSURE,
path=sc.API_VEHICLE_STATUS)
status = (await task)["status"]
assert_vehicle_status(status, VEHICLE_STATUS_G2)
async def test_remote_cmds(http_redirect, ssl_certificate):
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
controller = await setup_multi_session(server, http_redirect)
cmd_list = [
{
"command": controller.horn(TEST_VIN_2_EV),
"path": sc.API_HORN_LIGHTS
},
{
"command": controller.lights(TEST_VIN_2_EV),
"path": sc.API_LIGHTS
},
{
"command": controller.lock(TEST_VIN_2_EV),
"path": sc.API_LOCK
},
{
"command": controller.unlock(TEST_VIN_2_EV),
"path": sc.API_UNLOCK
},
{
"command": controller.charge_start(TEST_VIN_2_EV),
"path": sc.API_EV_CHARGE_NOW
},
{
"command": controller.remote_stop(TEST_VIN_2_EV),
"path": sc.API_G2_REMOTE_ENGINE_STOP
},
]
for cmd in cmd_list:
task = asyncio.create_task(cmd["command"])
await server_js_response(server,
VALIDATE_SESSION_FAIL,
path=sc.API_VALIDATE_SESSION)
await server_js_response(server,
LOGIN_MULTI_REGISTERED,
path=sc.API_LOGIN)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_2_EV,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
REMOTE_SERVICE_EXECUTE,
path=cmd["path"],
)
await server_js_response(server,
REMOTE_SERVICE_STATUS_STARTED,
path=sc.API_REMOTE_SVC_STATUS)
await server_js_response(
server,
REMOTE_SERVICE_STATUS_FINISHED_SUCCESS,
path=sc.API_REMOTE_SVC_STATUS,
)
assert await task
async def test_server(ssl_certificate):
"""Yield a local test server to use with server_js_response()."""
with patch("asyncio.sleep", new=CoroutineMock()):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
yield server
async def test_connect_multi_car(http_redirect, ssl_certificate):
async with CaseControlledTestServer(
ssl=ssl_certificate.server_context()) as server:
http_redirect.add_server(sc.MOBILE_API_SERVER[sc.COUNTRY_USA], 443,
server.port)
controller = subarulink.Controller(
http_redirect.session,
TEST_USERNAME,
TEST_PASSWORD,
TEST_DEVICE_ID,
TEST_PIN,
TEST_DEVICE_NAME,
)
task = asyncio.create_task(controller.connect())
await server_js_response(server,
LOGIN_MULTI_REGISTERED,
path=sc.API_LOGIN)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_1,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_1_G1,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
REFRESH_VEHICLES_MULTI_1,
path=sc.API_REFRESH_VEHICLES,
query={"_": str(int(time.time()))},
)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_2,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_2_EV,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
REFRESH_VEHICLES_MULTI_2,
path=sc.API_REFRESH_VEHICLES,
query={"_": str(int(time.time()))},
)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_3,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_3_G2,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
REFRESH_VEHICLES_MULTI_3,
path=sc.API_REFRESH_VEHICLES,
query={"_": str(int(time.time()))},
)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_4,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_4_SAFETY_PLUS,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
REFRESH_VEHICLES_MULTI_4,
path=sc.API_REFRESH_VEHICLES,
query={"_": str(int(time.time()))},
)
await server_js_response(server,
VALIDATE_SESSION_SUCCESS,
path=sc.API_VALIDATE_SESSION)
await server_js_response(
server,
SELECT_VEHICLE_5,
path=sc.API_SELECT_VEHICLE,
query={
"vin": TEST_VIN_5_G1_SECURITY,
"_": str(int(time.time()))
},
)
await server_js_response(
server,
REFRESH_VEHICLES_MULTI_5,
path=sc.API_REFRESH_VEHICLES,
query={"_": str(int(time.time()))},
)
response = await task
assert response
vehicles = controller.get_vehicles()
assert TEST_VIN_1_G1 in vehicles
assert TEST_VIN_2_EV in vehicles
assert TEST_VIN_3_G2 in vehicles
assert TEST_VIN_4_SAFETY_PLUS in vehicles
assert TEST_VIN_5_G1_SECURITY in vehicles
assert not controller.get_ev_status(TEST_VIN_1_G1)
assert controller.get_ev_status(TEST_VIN_2_EV)
assert not controller.get_remote_status(TEST_VIN_1_G1)
assert controller.get_remote_status(TEST_VIN_3_G2)
assert not controller.get_res_status(TEST_VIN_1_G1)
assert controller.get_remote_status(TEST_VIN_3_G2)
assert not controller.get_safety_status(TEST_VIN_1_G1)
assert controller.get_safety_status(TEST_VIN_4_SAFETY_PLUS)
