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)