def test_states(self):
"""Test parsing the different response types."""
rss = RemoteServiceStatus(load_response_json(_RESPONSE_INITIATED))
self.assertEqual(ExecutionState.INITIATED, rss.state)
rss = RemoteServiceStatus(load_response_json(_RESPONSE_PENDING))
self.assertEqual(ExecutionState.PENDING, rss.state)
rss = RemoteServiceStatus(load_response_json(_RESPONSE_DELIVERED))
self.assertEqual(ExecutionState.DELIVERED, rss.state)
rss = RemoteServiceStatus(load_response_json(_RESPONSE_EXECUTED))
self.assertEqual(ExecutionState.EXECUTED, rss.state)
def test_available_state_services(self):
"""Check that available_attributes returns exactly the arguments we have in our test data."""
backend_mock = BackendMock()
with mock.patch('bimmer_connected.account.requests', new=backend_mock):
account = ConnectedDriveAccount(TEST_USERNAME, TEST_PASSWORD,
TEST_REGION)
vehicles = load_response_json('vehicles.json')
for test_vehicle in vehicles['vehicles']:
vehicle = account.get_vehicle(test_vehicle['vin'])
print(vehicle.name)
services_to_check = {
k: v
for k, v in test_vehicle.items()
if k in list(AVAILABLE_STATES_MAPPING)
}
available_services = ['STATUS']
for key, value in services_to_check.items():
if AVAILABLE_STATES_MAPPING[key].get(value):
available_services += AVAILABLE_STATES_MAPPING[key][value]
if vehicle.drive_train != DriveTrainType.CONVENTIONAL:
available_services += ['EFFICIENCY', 'NAVIGATION']
self.assertListEqual(sorted(vehicle.available_state_services),
sorted(available_services))
def test_states(self):
"""Test parsing the different response types."""
rss = RemoteServiceStatus(
load_response_json('G31_NBTevo/RLF_INITIAL_RESPONSE.json'))
self.assertEqual(ExecutionState.PENDING, rss.state)
rss = RemoteServiceStatus(
load_response_json('G31_NBTevo/RLF_PENDING.json'))
self.assertEqual(ExecutionState.PENDING, rss.state)
rss = RemoteServiceStatus(
load_response_json('G31_NBTevo/RLF_DELIVERED.json'))
self.assertEqual(ExecutionState.DELIVERED, rss.state)
rss = RemoteServiceStatus(
load_response_json('G31_NBTevo/RLF_EXECUTED.json'))
self.assertEqual(ExecutionState.EXECUTED, rss.state)
def test_available_attributes(self):
"""Check that available_attributes returns exactly the arguments we have in our test data."""
backend_mock = BackendMock()
with mock.patch('bimmer_connected.account.requests', new=backend_mock):
account = ConnectedDriveAccount(TEST_USERNAME, TEST_PASSWORD, TEST_REGION)
for vin, dirname in TEST_VEHICLE_DATA.items():
vehicle = account.get_vehicle(vin)
print(vehicle.name)
status_data = load_response_json('{}/status.json'.format(dirname))
existing_attributes = status_data['vehicleStatus'].keys()
existing_attributes = sorted([ATTRIBUTE_MAPPING.get(a, a) for a in existing_attributes
if a not in MISSING_ATTRIBUTES])
expected_attributes = sorted([a for a in vehicle.available_attributes if a not in ADDITIONAL_ATTRIBUTES])
self.assertListEqual(existing_attributes, expected_attributes)
"""Tests for ConnectedDriveVehicle."""
import unittest
from unittest import mock
from test import load_response_json, BackendMock, TEST_USERNAME, TEST_PASSWORD, TEST_REGION, \
G31_VIN, F48_VIN, I01_VIN, I01_NOREX_VIN, F15_VIN, F45_VIN, TEST_VEHICLE_DATA, \
ATTRIBUTE_MAPPING, MISSING_ATTRIBUTES, ADDITIONAL_ATTRIBUTES
from bimmer_connected.vehicle import ConnectedDriveVehicle, DriveTrainType
from bimmer_connected.account import ConnectedDriveAccount
_VEHICLES = load_response_json('vehicles.json')['vehicles']
G31_VEHICLE = _VEHICLES[0]
class TestVehicle(unittest.TestCase):
"""Tests for ConnectedDriveVehicle."""
def test_drive_train(self):
"""Tests around drive_train attribute."""
vehicle = ConnectedDriveVehicle(None, G31_VEHICLE)
self.assertEqual(DriveTrainType.CONVENTIONAL, vehicle.drive_train)
def test_parsing_attributes(self):
"""Test parsing different attributes of the vehicle."""
backend_mock = BackendMock()
with mock.patch('bimmer_connected.account.requests', new=backend_mock):
account = ConnectedDriveAccount(TEST_USERNAME, TEST_PASSWORD, TEST_REGION)
for vehicle in account.vehicles:
print(vehicle.name)
"""Test for VehicleState."""
import unittest
from unittest import mock
import datetime
from test import load_response_json, TEST_REGION, TEST_PASSWORD, TEST_USERNAME, BackendMock, G31_VIN, \
ATTRIBUTE_MAPPING, MISSING_ATTRIBUTES, F48_VIN
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState, LidState, LockState, ConditionBasedServiceStatus, \
ParkingLightState, ChargingState
G31_TEST_DATA = load_response_json('G31_NBTevo/status.json')
G31_NO_POSITION_TEST_DATA = load_response_json(
'G31_NBTevo/status_position_disabled.json')
F48_TEST_DATA = load_response_json('F48/status.json')
I01_TEST_DATA = load_response_json('I01_REX/status.json')
class TestState(unittest.TestCase):
"""Test for VehicleState."""
# pylint: disable=protected-access
def test_parse_g31(self):
"""Test if the parsing of the attributes is working."""
account = unittest.mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes = G31_TEST_DATA['vehicleStatus']
self.assertEqual(4126, state.mileage)
"""Test for ChargingProfile"""
import unittest
from unittest import mock
from test import load_response_json
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState
from bimmer_connected.const import SERVICE_CHARGING_PROFILE
from bimmer_connected.charging_profile import ChargingMode, ChargingPreferences, TimerTypes
I01_TEST_DATA = load_response_json('I01_NOREX/charging_profile.json')
class TestState(unittest.TestCase):
"""Test for ChargingProfile."""
# pylint: disable=protected-access
def test_parse_i01(self):
"""Test if the parsing of the attributes is working."""
account = mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes[SERVICE_CHARGING_PROFILE] = I01_TEST_DATA[
'weeklyPlanner']
self.assertTrue(
state.charging_profile.is_pre_entry_climatization_enabled)
self.assertEqual(ChargingMode.DELAYED_CHARGING,
state.charging_profile.charging_mode)
self.assertEqual(ChargingPreferences.CHARGING_WINDOW,
state.charging_profile.charging_preferences)
self.assertTrue(state.charging_profile.pre_entry_climatization_timer[
"""Tests for ConnectedDriveVehicle."""
import unittest
from unittest import mock
from test import load_response_json, BackendMock, TEST_USERNAME, TEST_PASSWORD, TEST_COUNTRY
from bimmer_connected.vehicle import ConnectedDriveVehicle, DriveTrainType
from bimmer_connected.account import ConnectedDriveAccount
G31_VEHICLE = load_response_json('vehicles.json')[0]
F48_VEHICLE = load_response_json('vehicles.json')[1]
I01_VEHICLE = load_response_json('vehicles.json')[3]
class TestVehicle(unittest.TestCase):
"""Tests for ConnectedDriveVehicle."""
def test_has_rex(self):
"""Tests around hasRex attribute."""
vehicle = ConnectedDriveVehicle(None, G31_VEHICLE)
self.assertFalse(vehicle.has_rex)
vehicle.attributes['hasRex'] = '1'
self.assertTrue(vehicle.has_rex)
def test_drive_train(self):
"""Tests around drive_train attribute."""
vehicle = ConnectedDriveVehicle(None, G31_VEHICLE)
self.assertEqual(DriveTrainType.CONVENTIONAL, vehicle.drive_train)
vehicle = ConnectedDriveVehicle(None, F48_VEHICLE)
self.assertEqual(DriveTrainType.PHEV, vehicle.drive_train)
vehicle = ConnectedDriveVehicle(None, I01_VEHICLE)
"""Test for RangeMaps"""
import unittest
from unittest import mock
from test import load_response_json
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState
from bimmer_connected.const import SERVICE_RANGEMAP
from bimmer_connected.range_maps import RangeMapType, RangeMapQuality
I01_TEST_DATA = load_response_json('I01_NOREX/range_maps.json')
class TestState(unittest.TestCase):
"""Test for LastDestinations."""
# pylint: disable=protected-access
def test_parse_i01(self):
"""Test if the parsing of the attributes is working."""
account = mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes[SERVICE_RANGEMAP] = I01_TEST_DATA['rangemap']
self.assertEqual(RangeMapQuality.AVERAGE,
state.range_maps.range_map_quality)
self.assertEqual(51.123456, state.range_maps.range_map_center.latitude)
self.assertEqual(-1.2345678,
state.range_maps.range_map_center.longitude)
self.assertEqual(RangeMapType.ECO_PRO_PLUS,
state.range_maps.range_maps[0].range_map_type)
self.assertEqual(51.6991281509399,
state.range_maps.range_maps[0].polyline[0].latitude)
"""Test for VehicleState."""
import unittest
from unittest import mock
import datetime
from test import load_response_json, TEST_COUNTRY, TEST_PASSWORD, TEST_USERNAME, BackendMock, G31_VIN, F32_VIN
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState, LidState, LockState, ConditionBasedServiceStatus, \
ParkingLightState
G31_TEST_DATA = load_response_json('G31_NBTevo/dynamic.json')
NBT_TEST_DATA = load_response_json('unknown_NBT/dynamic.json')
F48_TEST_DATA = load_response_json('F48_EntryNav/dynamic.json')
F16_TEST_DATA = load_response_json('F16_NBTevo/dynamic.json')
class TestState(unittest.TestCase):
"""Test for VehicleState."""
# pylint: disable=protected-access
def test_parse_g31(self):
"""Test if the parsing of the attributes is working."""
account = unittest.mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes = G31_TEST_DATA['attributesMap']
self.assertEqual(2201, state.mileage)
self.assertEqual('km', state.unit_of_length)
self.assertEqual(datetime.datetime(2018, 2, 17, 12, 15, 36),
"""Test for AllTrips."""
import unittest
from unittest import mock
from test import load_response_json
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState
from bimmer_connected.const import SERVICE_ALL_TRIPS
I01_TEST_DATA = load_response_json('I01_NOREX/all_trips.json')
class TestState(unittest.TestCase):
"""Test for VehicleState."""
# pylint: disable=protected-access
def test_parse_i01(self):
"""Test if the parsing of the attributes is working."""
account = mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes[SERVICE_ALL_TRIPS] = I01_TEST_DATA['allTrips']
self.assertEqual('1970-01-01T01:00:00+0100', state.all_trips.reset_date)
self.assertEqual(35820, state.all_trips.battery_size_max)
self.assertEqual(87.58, state.all_trips.saved_co2)
self.assertEqual(515.177, state.all_trips.saved_co2_green_energy)
self.assertEqual(0, state.all_trips.total_saved_fuel)
self.assertEqual(0, state.all_trips.average_electric_consumption.community_low)
self.assertEqual(16.33, state.all_trips.average_electric_consumption.community_average)
self.assertEqual(35.53, state.all_trips.average_electric_consumption.community_high)
self.assertEqual(14.76, state.all_trips.average_electric_consumption.user_average)
"""Test for Efficiency"""
import unittest
from unittest import mock
from test import load_response_json
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState
from bimmer_connected.const import SERVICE_EFFICIENCY
G30_PHEV_OS7_TEST_DATA = load_response_json('G30_PHEV_OS7/efficiency.json')
class TestState(unittest.TestCase):
"""Test for Efficiency."""
# pylint: disable=protected-access
def test_parse_g30_phev_os7(self):
"""Test if the parsing of the attributes is working."""
account = mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes[SERVICE_EFFICIENCY] = G30_PHEV_OS7_TEST_DATA
self.assertEqual('PHEV', state.efficiency.model_type)
self.assertEqual(0, state.efficiency.efficiency_quotient)
self.assertEqual('LASTTRIP_DELTA_KM',
state.efficiency.last_trip_list[0].name)
self.assertEqual('KM', state.efficiency.last_trip_list[0].unit)
self.assertEqual('--', state.efficiency.last_trip_list[0].last_trip)
self.assertEqual('TIMESTAMP_STATISTICS_RESET',
state.efficiency.life_time_list[2].name)
self.assertIsNone(state.efficiency.life_time_list[2].unit)
self.assertEqual('12.01.2020',
"""Test for Navigation"""
import unittest
from unittest import mock
from test import load_response_json
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState
from bimmer_connected.const import SERVICE_NAVIGATION
G30_PHEV_OS7_TEST_DATA = load_response_json('G30_PHEV_OS7/navigation.json')
class TestState(unittest.TestCase):
"""Test for Navigation."""
# pylint: disable=protected-access
def test_parse_g30_phev_os7(self):
"""Test if the parsing of the attributes is working."""
account = mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes[SERVICE_NAVIGATION] = G30_PHEV_OS7_TEST_DATA
self.assertEqual(52.82273, state.navigation.latitude)
self.assertEqual(8.8276, state.navigation.longitude)
self.assertEqual('DEU', state.navigation.iso_country_code)
self.assertEqual(1.4, state.navigation.aux_power_regular)
self.assertEqual(1.2, state.navigation.aux_power_eco_pro)
self.assertEqual(0.4, state.navigation.aux_power_eco_pro_plus)
self.assertEqual(4.98700008381234, state.navigation.soc)
self.assertEqual(9.48, state.navigation.soc_max)
self.assertIsNone(state.navigation.eco)
self.assertIsNone(state.navigation.norm)
"""Test for VehicleState."""
import unittest
from unittest import mock
import datetime
from test import load_response_json, TEST_REGION, TEST_PASSWORD, TEST_USERNAME, BackendMock, G31_VIN, \
ATTRIBUTE_MAPPING, MISSING_ATTRIBUTES, F48_VIN
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState
from bimmer_connected.const import SERVICE_STATUS
from bimmer_connected.vehicle_status import LidState, LockState, ConditionBasedServiceStatus, \
ParkingLightState, ChargingState
G31_TEST_DATA = load_response_json('G31_NBTevo/status.json')
G31_NO_POSITION_TEST_DATA = load_response_json(
'G31_NBTevo/status_position_disabled.json')
G31_NO_POSTITION_VEHICLE_ACTIVE_TEST_DATA = load_response_json(
'G31_NBTevo/status_position_vehicle_active.json')
F48_TEST_DATA = load_response_json('F48/status.json')
I01_TEST_DATA = load_response_json('I01_REX/status.json')
class TestState(unittest.TestCase):
"""Test for VehicleState."""
# pylint: disable=protected-access
def test_parse_g31(self):
"""Test if the parsing of the attributes is working."""
account = unittest.mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
"""Test for LastDestinations"""
import unittest
from unittest import mock
from test import load_response_json
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState
from bimmer_connected.const import SERVICE_DESTINATIONS
from bimmer_connected.last_destinations import DestinationType
I01_TEST_DATA = load_response_json('I01_NOREX/last_destinations.json')
class TestState(unittest.TestCase):
"""Test for LastDestinations."""
# pylint: disable=protected-access
def test_parse_i01(self):
"""Test if the parsing of the attributes is working."""
account = mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes[SERVICE_DESTINATIONS] = I01_TEST_DATA['destinations']
self.assertEqual(DestinationType.DESTINATION, state.last_destinations.last_destinations[0].destination_type)
self.assertEqual(51.53053283691406, state.last_destinations.last_destinations[0].latitude)
self.assertEqual(-0.08362331241369247, state.last_destinations.last_destinations[0].longitude)
self.assertEqual('UNITED KINGDOM', state.last_destinations.last_destinations[0].country)
self.assertEqual('LONDON', state.last_destinations.last_destinations[0].city)
self.assertEqual('PITFIELD STREET', state.last_destinations.last_destinations[0].street)
self.assertEqual('2015-09-25T08:06:11+0200', state.last_destinations.last_destinations[0].created_at)
def test_available_attributes(self):
"""Test for LastTrip"""
import unittest
from unittest import mock
from test import load_response_json
from bimmer_connected.account import ConnectedDriveAccount
from bimmer_connected.state import VehicleState
from bimmer_connected.const import SERVICE_LAST_TRIP
I01_TEST_DATA = load_response_json('I01_NOREX/last_trip.json')
class TestState(unittest.TestCase):
"""Test for LastTrip."""
# pylint: disable=protected-access
def test_parse_i01(self):
"""Test if the parsing of the attributes is working."""
account = mock.MagicMock(ConnectedDriveAccount)
state = VehicleState(account, None)
state._attributes[SERVICE_LAST_TRIP] = I01_TEST_DATA['lastTrip']
self.assertEqual(0.53, state.last_trip.efficiencyValue)
self.assertEqual(141, state.last_trip.total_distance)
self.assertEqual(100.1, state.last_trip.electric_distance)
self.assertEqual(16.6, state.last_trip.averege_electric_consumption)
self.assertEqual(2, state.last_trip.averege_recuperation)
self.assertEqual(0, state.last_trip.driving_mode_value)
self.assertEqual(0.39, state.last_trip.acceleration_value)
self.assertEqual(0.81, state.last_trip.anticipation_value)
self.assertEqual(0.79, state.last_trip.total_consumption_value)
self.assertEqual(0.66, state.last_trip.auxiliary_consumption_value)
