def test_get_jwt_response() -> None:
"""Test get_jwt response."""
response: models.GigyaGetJWTResponse = fixtures.get_file_content_as_schema(
f"{fixtures.GIGYA_FIXTURE_PATH}/get_jwt.json",
schemas.GigyaGetJWTResponseSchema)
response.raise_for_error_code()
assert response.get_jwt() == "sample-jwt-token"
def test_vehicle_error_response(filename: str) -> None:
"""Test vehicle error response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
filename, schemas.KamereonVehicleDataResponseSchema)
with pytest.raises(exceptions.KamereonResponseException):
response.raise_for_error_code()
assert response.errors is not None
def test_vehicle_data_response(filename: str) -> None:
"""Test vehicle data response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
filename, schemas.KamereonVehicleDataResponseSchema)
response.raise_for_error_code()
# Ensure the VIN is hidden
assert response.data.id.startswith("VF1AAAA")
def test_vehicle_action_response(filename: str) -> None:
"""Test vehicle action response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
filename, schemas.KamereonVehicleDataResponseSchema)
response.raise_for_error_code()
# Ensure the guid is hidden
assert response.data.id == "guid"
def test_battery_status_1() -> None:
"""Test vehicle data for battery-status.1.json."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/battery-status.1.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
assert response.data.raw_data["attributes"] == {
"timestamp": "2020-11-17T09:06:48+01:00",
"batteryLevel": 50,
"batteryAutonomy": 128,
"batteryCapacity": 0,
"batteryAvailableEnergy": 0,
"plugStatus": 0,
"chargingStatus": -1.0,
}
vehicle_data = cast(
models.KamereonVehicleBatteryStatusData,
response.get_attributes(
schemas.KamereonVehicleBatteryStatusDataSchema),
)
assert vehicle_data.timestamp == "2020-11-17T09:06:48+01:00"
assert vehicle_data.batteryLevel == 50
assert vehicle_data.batteryTemperature is None
assert vehicle_data.batteryAutonomy == 128
assert vehicle_data.batteryCapacity == 0
assert vehicle_data.batteryAvailableEnergy == 0
assert vehicle_data.plugStatus == 0
assert vehicle_data.chargingStatus == -1.0
assert vehicle_data.chargingRemainingTime is None
assert vehicle_data.chargingInstantaneousPower is None
assert vehicle_data.get_plug_status() == enums.PlugState.UNPLUGGED
assert vehicle_data.get_charging_status() == enums.ChargeState.CHARGE_ERROR
def test_login_response() -> None:
"""Test login response."""
response: models.GigyaLoginResponse = fixtures.get_file_content_as_schema(
f"{fixtures.GIGYA_FIXTURE_PATH}/login.json",
schemas.GigyaLoginResponseSchema)
response.raise_for_error_code()
assert response.get_session_cookie() == "sample-cookie-value"
def test_vehicles_response(filename: str) -> None:
"""Test vehicles list response."""
response: models.KamereonVehiclesResponse = fixtures.get_file_content_as_schema(
filename, schemas.KamereonVehiclesResponseSchema
)
response.raise_for_error_code()
# Ensure the account id is hidden
assert response.accountId.startswith("account-id")
for vehicle_link in response.vehicleLinks:
# Ensure the VIN and RegistrationNumber are hidden
assert vehicle_link.vin
assert vehicle_link.vin.startswith("VF1AAAA"), "Ensure vin is obfuscated."
vehicle_details = vehicle_link.vehicleDetails
assert vehicle_details
assert vehicle_details.vin
assert vehicle_details.vin.startswith("VF1AAAA"), "Ensure vin is obfuscated."
assert vehicle_details.registrationNumber
assert vehicle_details.registrationNumber.startswith(
"REG-"
), "Ensure registrationNumber is obfuscated."
assert vehicle_details.radioCode == "1234", "Ensure radioCode is obfuscated."
generated_specs = {
"get_brand_label": vehicle_details.get_brand_label(),
"get_energy_code": vehicle_details.get_energy_code(),
"get_model_code": vehicle_details.get_model_code(),
"get_model_label": vehicle_details.get_model_label(),
"reports_charging_power_in_watts": vehicle_details.reports_charging_power_in_watts(), # noqa: B950
"uses_electricity": vehicle_details.uses_electricity(),
"uses_fuel": vehicle_details.uses_fuel(),
"supports-hvac-status": vehicle_details.supports_endpoint("hvac-status"),
"supports-location": vehicle_details.supports_endpoint("location"),
}
assert EXPECTED_SPECS[os.path.basename(filename)] == generated_specs
def test_get_account_info_response() -> None:
"""Test get_account_info response."""
response: models.GigyaGetAccountInfoResponse = fixtures.get_file_content_as_schema(
f"{fixtures.GIGYA_FIXTURE_PATH}/get_account_info.json",
schemas.GigyaGetAccountInfoResponseSchema,
)
response.raise_for_error_code()
assert response.get_person_id() == "person-id-1"
def test_get_jwt_403013_response() -> None:
"""Test get_jwt.403013 response."""
response: models.GigyaGetJWTResponse = fixtures.get_file_content_as_schema(
f"{fixtures.GIGYA_FIXTURE_PATH}/error/get_jwt.403013.json",
schemas.GigyaGetJWTResponseSchema,
)
with pytest.raises(exceptions.GigyaResponseException) as excinfo:
response.raise_for_error_code()
assert excinfo.value.error_code == 403013
assert excinfo.value.error_details == "Unverified user"
def test_vehicle_error_access_denied() -> None:
"""Test vehicle access_denied response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/error/access_denied.json",
schemas.KamereonVehicleDataResponseSchema,
)
with pytest.raises(exceptions.AccessDeniedException) as excinfo:
response.raise_for_error_code()
assert excinfo.value.error_code == "err.func.403"
assert excinfo.value.error_details == "Access is denied for this resource"
def test_vehicle_error_resource_not_found() -> None:
"""Test vehicle resource_not_found response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/error/resource_not_found.json",
schemas.KamereonVehicleDataResponseSchema,
)
with pytest.raises(exceptions.ResourceNotFoundException) as excinfo:
response.raise_for_error_code()
assert excinfo.value.error_code == "err.func.wired.notFound"
assert excinfo.value.error_details == "Resource not found"
def test_vehicle_error_quota_limit() -> None:
"""Test vehicle quota_limit response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/error/quota_limit.json",
schemas.KamereonVehicleDataResponseSchema,
)
with pytest.raises(exceptions.QuotaLimitException) as excinfo:
response.raise_for_error_code()
assert excinfo.value.error_code == "err.func.wired.overloaded"
assert excinfo.value.error_details == "You have reached your quota limit"
def test_login_403042_response() -> None:
"""Test login.403042 response."""
response: models.GigyaLoginResponse = fixtures.get_file_content_as_schema(
f"{fixtures.GIGYA_FIXTURE_PATH}/error/login.403042.json",
schemas.GigyaLoginResponseSchema,
)
with pytest.raises(exceptions.InvalidCredentialsException) as excinfo:
response.raise_for_error_code()
assert excinfo.value.error_code == 403042
assert excinfo.value.error_details == "invalid loginID or password"
def test_vehicle_error_invalid_date() -> None:
"""Test vehicle invalid_date response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/error/invalid_date.json",
schemas.KamereonVehicleDataResponseSchema,
)
with pytest.raises(exceptions.InvalidInputException) as excinfo:
response.raise_for_error_code()
assert excinfo.value.error_code == "err.func.400"
assert (excinfo.value.error_details ==
"/data/attributes/startDateTime must be a future date")
def test_vehicle_action_response_attributes() -> None:
"""Test vehicle action response attributes."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_action/hvac-start.start.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
assert response.data.raw_data["attributes"] == {
"action": "start",
"targetTemperature": 21.0,
}
def test_vehicle_error_not_supported() -> None:
"""Test vehicle not_supported response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/error/not_supported.json",
schemas.KamereonVehicleDataResponseSchema,
)
with pytest.raises(exceptions.NotSupportedException) as excinfo:
response.raise_for_error_code()
assert excinfo.value.error_code == "err.tech.501"
assert (excinfo.value.error_details ==
"This feature is not technically supported by this gateway")
def test_vehicle_error_invalid_upstream() -> None:
"""Test vehicle invalid_upstream response."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/error/invalid_upstream.json",
schemas.KamereonVehicleDataResponseSchema,
)
with pytest.raises(exceptions.InvalidUpstreamException) as excinfo:
response.raise_for_error_code()
assert excinfo.value.error_code == "err.tech.500"
assert (
excinfo.value.error_details ==
"Invalid response from the upstream server (The request sent to the GDC"
" is erroneous) ; 502 Bad Gateway")
def test_hvac_settings_mode() -> None:
"""Test vehicle data with hvac settings for mode."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/hvac-settings.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
vehicle_data = cast(
models.KamereonVehicleHvacSettingsData,
response.get_attributes(schemas.KamereonVehicleHvacSettingsDataSchema),
)
assert vehicle_data.mode == "scheduled"
def test_zoe40_2() -> None:
"""Test vehicle details for zoe_40.2.json."""
response: models.KamereonVehiclesResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicles/zoe_40.2.json",
schemas.KamereonVehiclesResponseSchema,
)
vehicle_details = response.vehicleLinks[0].vehicleDetails
assert vehicle_details
assert vehicle_details.get_brand_label() == "RENAULT"
assert vehicle_details.get_energy_code() == "ELEC"
assert vehicle_details.get_model_code() == "X101VE"
assert vehicle_details.get_model_label() == "ZOE"
assert vehicle_details.reports_charging_power_in_watts()
assert vehicle_details.uses_electricity()
assert not vehicle_details.uses_fuel()
def test_charge_mode() -> None:
"""Test vehicle data for charge-mode.json."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/charge-mode.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
assert response.data.raw_data["attributes"] == {"chargeMode": "always"}
vehicle_data = cast(
models.KamereonVehicleChargeModeData,
response.get_attributes(schemas.KamereonVehicleChargeModeDataSchema),
)
assert vehicle_data.chargeMode == "always"
def test_capturii_1() -> None:
"""Test vehicle details for captur_ii.1.json."""
response: models.KamereonVehiclesResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicles/captur_ii.1.json",
schemas.KamereonVehiclesResponseSchema,
)
vehicle_details = response.vehicleLinks[0].vehicleDetails
assert vehicle_details
assert vehicle_details.get_brand_label() == "RENAULT"
assert vehicle_details.get_energy_code() == "ESS"
assert vehicle_details.get_model_code() == "XJB1SU"
assert vehicle_details.get_model_label() == "CAPTUR II"
assert not vehicle_details.reports_charging_power_in_watts()
assert not vehicle_details.uses_electricity()
assert vehicle_details.uses_fuel()
def test_cockpit_zoe() -> None:
"""Test vehicle data for cockpit.zoe.json."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/cockpit.zoe.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
assert response.data.raw_data["attributes"] == {"totalMileage": 49114.27}
vehicle_data = cast(
models.KamereonVehicleCockpitData,
response.get_attributes(schemas.KamereonVehicleCockpitDataSchema),
)
assert vehicle_data.totalMileage == 49114.27
assert vehicle_data.fuelAutonomy is None
assert vehicle_data.fuelQuantity is None
def test_person_response() -> None:
"""Test person details response."""
response: models.KamereonPersonResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/person.json",
schemas.KamereonPersonResponseSchema,
)
response.raise_for_error_code()
assert response.accounts[0].accountId == "account-id-1"
assert response.accounts[0].accountType == "MYRENAULT"
assert response.accounts[0].accountStatus == "ACTIVE"
assert response.accounts[1].accountId == "account-id-2"
assert response.accounts[1].accountType == "SFDC"
assert response.accounts[1].accountStatus == "ACTIVE"
for account in response.accounts:
assert account.accountId
assert account.accountId.startswith("account-id")
def test_location() -> None:
"""Test vehicle data for location.json."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/location.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
assert response.data.raw_data["attributes"] == {
"gpsLatitude": 48.1234567,
"gpsLongitude": 11.1234567,
"lastUpdateTime": "2020-02-18T16:58:38Z",
}
vehicle_data = cast(
models.KamereonVehicleLocationData,
response.get_attributes(schemas.KamereonVehicleLocationDataSchema),
)
assert vehicle_data.gpsLatitude == 48.1234567
assert vehicle_data.gpsLongitude == 11.1234567
assert vehicle_data.lastUpdateTime == "2020-02-18T16:58:38Z"
def test_cockpit_captur_ii() -> None:
"""Test vehicle data for cockpit.captur_ii.json."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/cockpit.captur_ii.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
assert response.data.raw_data["attributes"] == {
"fuelAutonomy": 35.0,
"fuelQuantity": 3.0,
"totalMileage": 5566.78,
}
vehicle_data = cast(
models.KamereonVehicleCockpitData,
response.get_attributes(schemas.KamereonVehicleCockpitDataSchema),
)
assert vehicle_data.totalMileage == 5566.78
assert vehicle_data.fuelAutonomy == 35.0
assert vehicle_data.fuelQuantity == 3.0
def test_battery_status_2() -> None:
"""Test vehicle data for battery-status.2.json."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/battery-status.2.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
assert response.data.raw_data["attributes"] == {
"timestamp": "2020-01-12T21:40:16Z",
"batteryLevel": 60,
"batteryTemperature": 20,
"batteryAutonomy": 141,
"batteryCapacity": 0,
"batteryAvailableEnergy": 31,
"plugStatus": 1,
"chargingStatus": 1.0,
"chargingRemainingTime": 145,
"chargingInstantaneousPower": 27.0,
}
vehicle_data = cast(
models.KamereonVehicleBatteryStatusData,
response.get_attributes(
schemas.KamereonVehicleBatteryStatusDataSchema),
)
assert vehicle_data.timestamp == "2020-01-12T21:40:16Z"
assert vehicle_data.batteryLevel == 60
assert vehicle_data.batteryTemperature == 20
assert vehicle_data.batteryAutonomy == 141
assert vehicle_data.batteryCapacity == 0
assert vehicle_data.batteryAvailableEnergy == 31
assert vehicle_data.plugStatus == 1
assert vehicle_data.chargingStatus == 1.0
assert vehicle_data.chargingRemainingTime == 145
assert vehicle_data.chargingInstantaneousPower == 27.0
assert vehicle_data.get_plug_status() == enums.PlugState.PLUGGED
assert vehicle_data.get_charging_status(
) == enums.ChargeState.CHARGE_IN_PROGRESS
def test_hvac_settings_schedule() -> None:
"""Test vehicle data with hvac schedule entries."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/hvac-settings.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
vehicle_data = cast(
models.KamereonVehicleHvacSettingsData,
response.get_attributes(schemas.KamereonVehicleHvacSettingsDataSchema),
)
assert vehicle_data.mode == "scheduled"
assert vehicle_data.schedules[1].id == 2
assert vehicle_data.schedules[1].wednesday.readyAtTime == "T15:15Z"
assert vehicle_data.schedules[1].friday.readyAtTime == "T15:15Z"
assert vehicle_data.schedules[1].monday is None
for i in [0, 2, 3, 4]:
assert vehicle_data.schedules[i].id == i + 1
for day in DAYS_OF_WEEK:
assert vehicle_data.schedules[i].__dict__.get(day) is None
def test_vehicles_response(filename: str) -> None:
"""Test vehicles list response."""
response: models.KamereonVehiclesResponse = fixtures.get_file_content_as_schema(
filename, schemas.KamereonVehiclesResponseSchema)
response.raise_for_error_code()
# Ensure the account id is hidden
assert response.accountId.startswith("account-id")
for vehicle_link in response.vehicleLinks:
# Ensure the VIN and RegistrationNumber are hidden
assert vehicle_link.vin
assert vehicle_link.vin.startswith("VF1AAAA")
vehicle_details = vehicle_link.vehicleDetails
assert vehicle_details
assert vehicle_details.vin
assert vehicle_details.vin.startswith("VF1AAAA")
assert vehicle_details.registrationNumber
assert vehicle_details.registrationNumber.startswith("REG-")
# Ensure the methods work
assert vehicle_details.get_brand_label()
assert vehicle_details.get_energy_code()
assert vehicle_details.get_model_code()
assert vehicle_details.get_model_label()
def test_valid_response(filename: str) -> None:
"""Test all valid responses."""
response: models.GigyaResponse = fixtures.get_file_content_as_schema(
filename, schemas.GigyaResponseSchema)
response.raise_for_error_code()
def test_charging_settings_multi() -> None:
"""Test vehicle data for charging-settings.json."""
response: models.KamereonVehicleDataResponse = fixtures.get_file_content_as_schema(
f"{fixtures.KAMEREON_FIXTURE_PATH}/vehicle_data/charging-settings.multi.json",
schemas.KamereonVehicleDataResponseSchema,
)
response.raise_for_error_code()
assert response.data.raw_data["attributes"] == {
"mode":
"scheduled",
"schedules": [
{
"id": 1,
"activated": True,
"monday": {
"startTime": "T00:00Z",
"duration": 450
},
"tuesday": {
"startTime": "T00:00Z",
"duration": 450
},
"wednesday": {
"startTime": "T00:00Z",
"duration": 450
},
"thursday": {
"startTime": "T00:00Z",
"duration": 450
},
"friday": {
"startTime": "T00:00Z",
"duration": 450
},
"saturday": {
"startTime": "T00:00Z",
"duration": 450
},
"sunday": {
"startTime": "T00:00Z",
"duration": 450
},
},
{
"id": 2,
"activated": True,
"monday": {
"startTime": "T23:30Z",
"duration": 15
},
"tuesday": {
"startTime": "T23:30Z",
"duration": 15
},
"wednesday": {
"startTime": "T23:30Z",
"duration": 15
},
"thursday": {
"startTime": "T23:30Z",
"duration": 15
},
"friday": {
"startTime": "T23:30Z",
"duration": 15
},
"saturday": {
"startTime": "T23:30Z",
"duration": 15
},
"sunday": {
"startTime": "T23:30Z",
"duration": 15
},
},
{
"id": 3,
"activated": False
},
{
"id": 4,
"activated": False
},
{
"id": 5,
"activated": False
},
],
}
vehicle_data = cast(
models.KamereonVehicleChargingSettingsData,
response.get_attributes(
schemas.KamereonVehicleChargingSettingsDataSchema),
)
assert vehicle_data.mode == "scheduled"
assert len(vehicle_data.schedules) == 5
schedule_data = vehicle_data.schedules[0]
assert schedule_data.id == 1
assert schedule_data.activated is True
assert schedule_data.monday.startTime == "T00:00Z"
assert schedule_data.monday.duration == 450
assert schedule_data.tuesday.startTime == "T00:00Z"
assert schedule_data.tuesday.duration == 450
assert schedule_data.wednesday.startTime == "T00:00Z"
assert schedule_data.wednesday.duration == 450
assert schedule_data.thursday.startTime == "T00:00Z"
assert schedule_data.thursday.duration == 450
assert schedule_data.friday.startTime == "T00:00Z"
assert schedule_data.friday.duration == 450
assert schedule_data.saturday.startTime == "T00:00Z"
assert schedule_data.saturday.duration == 450
assert schedule_data.sunday.startTime == "T00:00Z"
assert schedule_data.sunday.duration == 450
