def test_get_in_system_by_id(monkeypatch): system = models.System(id=SYSTEM_ID) route = models.Route(id=ROUTE_ID, color=ROUTE_COLOR, system=system) agency_1 = models.Agency(system=system, id=AGENCY_ONE_ID, name=AGENCY_ONE_NAME, routes=[route], alerts=[]) monkeypatch.setattr(genericqueries, "get_in_system_by_id", lambda *args: agency_1) monkeypatch.setattr(alertqueries, "get_agency_pk_to_active_alerts", lambda *args, **kwargs: {}) expected = views.AgencyLarge( id=AGENCY_ONE_ID, name=AGENCY_ONE_NAME, timezone=None, url=None, routes=[ views.Route(id=ROUTE_ID, color=ROUTE_COLOR, _system_id=SYSTEM_ID) ], alerts=[], ) actual = agencyservice.get_in_system_by_id(SYSTEM_ID, AGENCY_ONE_ID) assert expected == actual
def test_mark_update_completed( mock_systemdam, monkeypatch, prior_auto_update_setting, initial_system_status, final_status, post_system_status, ): monkeypatch.setattr(time, "time", lambda: CURRENT_TIMESTAMP + 99) system = models.System( auto_update_enabled=False, status=initial_system_status, id=SYSTEM_ID, ) mock_systemdam.create(system) update = models.SystemUpdate(pk=SYSTEM_UPDATE_PK, status=models.SystemUpdate.Status.IN_PROGRESS) mock_systemdam.create_update(update) context = systemservice._SystemUpdateContext( update_pk=SYSTEM_UPDATE_PK, system_id=SYSTEM_ID, prior_auto_update_setting=prior_auto_update_setting, start_time=CURRENT_TIMESTAMP, ) systemservice._mark_update_completed(context, final_status, "message") assert update.status is final_status assert update.status_message == "message" assert update.total_duration == 99 assert system.auto_update_enabled is prior_auto_update_setting assert system.status is post_system_status
def test_mark_update_started( mock_systemdam, monkeypatch, prior_auto_update_setting, initial_system_status, post_system_status, ): monkeypatch.setattr(time, "time", lambda: CURRENT_TIMESTAMP) system = models.System( auto_update_enabled=prior_auto_update_setting, status=initial_system_status, id=SYSTEM_ID, ) mock_systemdam.create(system) mock_systemdam.create_update( models.SystemUpdate(pk=SYSTEM_UPDATE_PK, status=models.SystemUpdate.Status.SCHEDULED)) context = systemservice._mark_update_started(SYSTEM_UPDATE_PK) assert context == systemservice._SystemUpdateContext( update_pk=SYSTEM_UPDATE_PK, system_id=SYSTEM_ID, prior_auto_update_setting=prior_auto_update_setting, start_time=CURRENT_TIMESTAMP, ) assert system.status == post_system_status assert system.auto_update_enabled is False
def test_list_all_in_system(monkeypatch): system = models.System(id=SYSTEM_ID) agency_1 = models.Agency(system=system, id=AGENCY_ONE_ID, name=AGENCY_ONE_NAME) agency_2 = models.Agency(system=system, id=AGENCY_TWO_ID, name=AGENCY_TWO_NAME) monkeypatch.setattr(systemqueries, "get_by_id", lambda *args, **kwargs: system) monkeypatch.setattr(genericqueries, "list_in_system", lambda *args: [agency_1, agency_2]) monkeypatch.setattr(alertqueries, "get_agency_pk_to_active_alerts", lambda *args, **kwargs: {}) expected = [ views.Agency(id=AGENCY_ONE_ID, _system_id=SYSTEM_ID, name=AGENCY_ONE_NAME, alerts=[]), views.Agency(id=AGENCY_TWO_ID, _system_id=SYSTEM_ID, name=AGENCY_TWO_NAME, alerts=[]), ] actual = agencyservice.list_all_in_system(SYSTEM_ID) assert actual == expected
def test_build_stop_pk_to_service_maps_response(monkeypatch): system = models.System(id=SYSTEM_ID) route_1 = models.Route(id=ROUTE_1_ID, system=system) route_2 = models.Route(id=ROUTE_2_ID, system=system) monkeypatch.setattr( servicemapmanager, "build_stop_pk_to_group_id_to_inherited_routes_map", lambda *args: {STOP_1_PK: {GROUP_ID: [route_1, route_2]}}, ) expected = { STOP_1_PK: [ views.ServiceMapWithRoutes( GROUP_ID, [ views.Route(ROUTE_1_ID, None, SYSTEM_ID), views.Route(ROUTE_2_ID, None, SYSTEM_ID), ], ) ] } actual = servicemapmanager.build_stop_pk_to_service_maps_response([STOP_1_PK]) assert expected == actual
def test_delete__async_case(mock_systemdam, monkeypatch): monkeypatch.setattr(uuid, "uuid4", lambda: "uuid") monkeypatch.setattr(systemservice, "_complete_delete_operation_async", mock.MagicMock()) system = models.System(id=SYSTEM_ID) mock_systemdam.create(system) systemservice.delete_by_id(SYSTEM_ID, sync=False) assert system.status is models.System.SystemStatus.DELETING assert system.id == SYSTEM_ID + "_deleting_uuid"
def test_calculate_schedule_service_map_for_route(monkeypatch): monkeypatch.setattr(dbconnection, "get_session", mock.MagicMock()) monkeypatch.setattr( schedulequeries, "get_scheduled_trip_pk_to_path_in_system", lambda *args, **kwargs: {TRIP_1_PK: [1, 2, 3, 4], TRIP_2_PK: [3, 1, 0]}, ) monkeypatch.setattr( stopqueries, "get_stop_pk_to_station_pk_map_in_system", lambda *args, **kwargs: {0: 0, 1: 11, 2: 2, 3: 3, 4: 14}, ) system = models.System( id=SYSTEM_ID, pk=SYSTEM_PK, service_map_groups=[ models.ServiceMapGroup( source=models.ServiceMapGroup.ServiceMapSource.SCHEDULE, threshold=0.05 ) ], ) trip_one = models.ScheduledTrip( pk=TRIP_1_PK, route_pk=ROUTE_1_PK, direction_id=True ) trip_two = models.ScheduledTrip( pk=TRIP_2_PK, route_pk=ROUTE_1_PK, direction_id=False ) monkeypatch.setattr( schedulequeries, "list_scheduled_trips_with_times_in_system", lambda *args, **kwargs: [ (trip_one, TRIP_1_START_TIME, TRIP_1_END_TIME), (trip_two, TRIP_2_START_TIME, TRIP_2_END_TIME), ], ) matcher = mock.MagicMock() matcher.return_value = True monkeypatch.setattr( servicemapmanager, "_ScheduledTripMatcher", lambda *args, **kwargs: matcher ) _build_service_map_from_paths = mock.MagicMock() monkeypatch.setattr( servicemapmanager, "_build_service_map_from_paths", _build_service_map_from_paths, ) expected_paths = {(11, 2, 3, 14), (0, 11, 3)} servicemapmanager.calculate_scheduled_service_maps_for_system(system) _build_service_map_from_paths.assert_has_calls([mock.call(expected_paths)])
def test_save_service_map_configuration(monkeypatch, session_factory): session = session_factory() monkeypatch.setattr(dbconnection, "get_session", lambda: session) existing_map_1 = models.ServiceMapGroup(pk=SERVICE_MAP_PK_1, id=SERVICE_MAP_ID_1) existing_map_2 = models.ServiceMapGroup(pk=SERVICE_MAP_PK_2, id=SERVICE_MAP_ID_2, conditions="{'key': 'value2'}") system = models.System(service_map_groups=[existing_map_1, existing_map_2]) service_maps_config = { SERVICE_MAP_ID_2: { "source": models.ServiceMapGroup.ServiceMapSource.SCHEDULE, "threshold": 0.2, "use_for_routes_at_stop": False, "use_for_stops_in_route": True, }, SERVICE_MAP_ID_3: { "source": models.ServiceMapGroup.ServiceMapSource.REALTIME, "threshold": 0.3, "use_for_routes_at_stop": True, "use_for_stops_in_route": False, "conditions": { "key": "value" }, }, } expected_map_1 = models.ServiceMapGroup( pk=SERVICE_MAP_PK_2, id=SERVICE_MAP_ID_2, conditions=None, source=models.ServiceMapGroup.ServiceMapSource.SCHEDULE, threshold=0.2, use_for_routes_at_stop=False, use_for_stops_in_route=True, ) conditions = "{\n" ' "key": "value"\n' "}" expected_map_2 = models.ServiceMapGroup( id=SERVICE_MAP_ID_3, conditions=conditions, source=models.ServiceMapGroup.ServiceMapSource.REALTIME, threshold=0.3, use_for_routes_at_stop=True, use_for_stops_in_route=False, ) systemservice._save_service_map_configuration(system, service_maps_config) assert [expected_map_1, expected_map_2] == session.merged assert [existing_map_1] == session.deleted
def tree_factory(number_of_stops, adjacency_tuples, not_stations=None): system = models.System(id="system_id") stops = [ models.Stop(pk=i, id=str(i), type=models.Stop.Type.STATION, system=system) for i in range(number_of_stops) ] for stop_pk, parent_pk in adjacency_tuples: stops[stop_pk].parent_stop_pk = parent_pk if not_stations is not None: for not_station in not_stations: stops[not_station].type = models.Stop.Type.PLATFORM return stops
def test_build_trip_stop_time_response(): system = models.System(id=SYSTEM_ID) stop = models.Stop(system=system) stop.id = STOP_ONE_ID trip = models.Trip(current_stop_sequence=1) trip.pk = TRIP_PK trip.id = TRIP_ID trip_stop_time = models.TripStopTime(arrival_time=TIME_1, departure_time=TIME_2, stop_sequence=1) trip_stop_time.trip = trip trip_stop_time.stop = stop route = models.Route(system=system) route.id = ROUTE_ID trip.route = route last_stop = models.Stop(system=system, id=STOP_TWO_ID, name=STOP_TWO_NAME) last_stop.id = STOP_TWO_ID expected = views.TripStopTime( arrival=views._TripStopTimeEvent(time=TIME_1, delay=None, uncertainty=None), departure=views._TripStopTimeEvent(time=TIME_2, delay=None, uncertainty=None), track=None, future=True, stop_sequence=1, direction=DIRECTION_NAME, trip=views.Trip( id=TRIP_ID, direction_id=None, started_at=None, updated_at=None, vehicle=None, _route_id=ROUTE_ID, _system_id=SYSTEM_ID, route=views.Route(id=ROUTE_ID, color=None, _system_id=SYSTEM_ID), last_stop=views.Stop(id=STOP_TWO_ID, name=STOP_TWO_NAME, _system_id=SYSTEM_ID), ), ) actual = stopservice._build_trip_stop_time_response( trip_stop_time, DIRECTION_NAME, {trip.pk: last_stop}) assert expected == actual
def test_execute_feed_update( monkeypatch, inline_unit_of_work, custom_parser, feed_content, previous_content, expected_status, expected_explanation, ): system = models.System(id=SYSTEM_ID) feed = models.Feed(id=FEED_ID, system=system, custom_parser=custom_parser, url=URL, headers="{}") feed_update = models.FeedUpdate(feed=feed) response = mock.MagicMock() if feed_content is None: response.raise_for_status.side_effect = requests.exceptions.RequestException( ) else: response.content = feed_content def get(*args, **kwargs): return response monkeypatch.setattr(requests, "get", get) def get_update_by_pk(feed_update_pk): return feed_update def get_last_successful_update(*args, **kwargs): if previous_content is None: return None m = hashlib.md5() m.update(previous_content) return m.hexdigest() monkeypatch.setattr(feedqueries, "get_update_by_pk", get_update_by_pk) monkeypatch.setattr(feedqueries, "get_last_successful_update_hash", get_last_successful_update) monkeypatch.setattr(import_, "run_import", lambda: (0, 0, 0)) feed_update, _ = updatemanager.execute_feed_update(1) assert feed_update.status == expected_status assert feed_update.result == expected_explanation
def test_geographical_search(monkeypatch): system = models.System(id="system_id") stop_1 = models.Stop(pk=1, id="1", name="1", latitude=0.1, longitude=0.1, system=system) stop_2 = models.Stop(pk=3, id="3", name="3", latitude=0.3, longitude=0.3, system=system) stop_3 = models.Stop(pk=5, id="5", name="5", latitude=0.5, longitude=0.5, system=system) monkeypatch.setattr( stopqueries, "list_all_in_geographical_bounds", lambda *args, **kwargs: [stop_3, stop_2, stop_1], ) actual_stops = stopservice.geographical_search("system_id", 0, 0, geography.distance( 0, 0, 0.4, 0.4), return_service_maps=False) assert [ views.Stop( id="1", name="1", _system_id="system_id", distance=int(geography.distance(0, 0, 0.1, 0.1)), ), views.Stop( id="3", name="3", _system_id="system_id", distance=int(geography.distance(0, 0, 0.3, 0.3)), ), ] == actual_stops
def test_delete__regular_case(mock_systemdam, monkeypatch): create_feed_flush = mock.MagicMock() monkeypatch.setattr(updatemanager, "create_feed_flush", create_feed_flush) monkeypatch.setattr(updatemanager, "execute_feed_update", mock.MagicMock()) delete_in_system_by_id = mock.MagicMock() monkeypatch.setattr(feedqueries, "delete_in_system_by_id", delete_in_system_by_id) system = models.System(id=SYSTEM_ID) system.feeds = [models.Feed(id=FEED_ID_1)] mock_systemdam.create(system) systemservice.delete_by_id(SYSTEM_ID) assert mock_systemdam.get_by_id(SYSTEM_ID) is None create_feed_flush.assert_called_once_with(SYSTEM_ID, FEED_ID_1) delete_in_system_by_id.assert_called_once_with(SYSTEM_ID, FEED_ID_1)
def test_list_systems_invalid_input(monkeypatch, function, inputted_system_ids): actual_system_ids = {"1", "2"} monkeypatch.setattr( systemqueries, "list_all", lambda system_ids: [ models.System(id=id_) for id_ in actual_system_ids if id_ in system_ids ], ) monkeypatch.setattr(transfersconfigqueries, "get", lambda args: models.TransfersConfig) with pytest.raises(exceptions.InvalidInput): function(inputted_system_ids, 100)
def test_list_all_in_system(monkeypatch): system = models.System(id=SYSTEM_ID) stop_one = models.Stop(pk=STOP_ONE_PK, id=STOP_ONE_ID, name=STOP_ONE_NAME, system=system) monkeypatch.setattr(systemqueries, "get_by_id", lambda *args, **kwargs: system) monkeypatch.setattr(stopqueries, "list_all_in_system", lambda *args: [stop_one]) expected = [ views.Stop(id=STOP_ONE_ID, name=STOP_ONE_NAME, _system_id=SYSTEM_ID) ] actual = stopservice.list_all_in_system(SYSTEM_ID) assert expected == actual
def test_calculate_realtime_service_map_for_route(inline_unit_of_work, monkeypatch): monkeypatch.setattr(dbconnection, "get_session", mock.MagicMock()) service_map_group = models.ServiceMapGroup( source=models.ServiceMapGroup.ServiceMapSource.REALTIME ) route_1 = models.Route( pk=ROUTE_1_PK, id=ROUTE_1_ID, system=models.System(service_map_groups=[service_map_group]), trips=[ models.Trip(pk=TRIP_1_PK, direction_id=True), models.Trip(pk=TRIP_2_PK, direction_id=False), ], ) monkeypatch.setattr( tripqueries, "get_trip_pk_to_path_map", lambda *args, **kwargs: {TRIP_1_PK: [1, 2, 3, 4], TRIP_2_PK: [3, 1, 0]}, ) monkeypatch.setattr( stopqueries, "get_stop_pk_to_station_pk_map_in_system", lambda *args, **kwargs: {0: 0, 1: 11, 2: 2, 3: 3, 4: 14}, ) new_service_map = models.ServiceMap() _build_service_map_from_paths = mock.MagicMock() monkeypatch.setattr( servicemapmanager, "_build_service_map_from_paths", _build_service_map_from_paths, ) _build_service_map_from_paths.return_value = new_service_map expected_paths = {(11, 2, 3, 14), (0, 11, 3)} servicemapmanager.calculate_realtime_service_map_for_route(route_1) _build_service_map_from_paths.assert_called_once_with(expected_paths) assert route_1.pk == new_service_map.route_pk assert service_map_group.pk == new_service_map.group_pk
def test_execute_feed_update__success_or_sync_error(inline_unit_of_work, monkeypatch, sync_error, expected_status, expected_explanation): system = models.System(id=SYSTEM_ID) feed = models.Feed(id=FEED_ID, system=system, custom_parser="custom_parser", url=URL, headers="{}") feed_update = models.FeedUpdate(feed=feed) response = mock.MagicMock() response.content = b"a" monkeypatch.setattr(requests, "get", lambda *args, **kwargs: response) monkeypatch.setattr(feedqueries, "get_update_by_pk", lambda *args: feed_update) monkeypatch.setattr(feedqueries, "get_last_successful_update_hash", lambda *args: None) class Parser(parse.TransiterParser): def load_content(self, content: bytes): pass monkeypatch.setattr(updatemanager, "_get_parser", lambda *args: Parser()) def sync_func(feed_update_pk, entities): if sync_error: raise ValueError return importdriver.ImportStats() monkeypatch.setattr(import_, "run_import", sync_func) feed_update, _ = updatemanager.execute_feed_update(1) assert feed_update.status == expected_status assert feed_update.result == expected_explanation
def test_get_by_id(monkeypatch): def count(relationship, system): return { models.System.stops: SYSTEM_ONE_NUM_STOPS, models.System.feeds: SYSTEM_ONE_NUM_FEEDS, models.System.routes: SYSTEM_ONE_NUM_ROUTES, models.System.agencies: SYSTEM_ONE_NUM_AGENCIES, models.System.transfers: SYSTEM_ONE_NUM_TRANSFERS, }[relationship] system = models.System(id=SYSTEM_ONE_ID, name=SYSTEM_ONE_NAME, status=models.System.SystemStatus.ACTIVE) expected = views.SystemLarge( id=SYSTEM_ONE_ID, status=models.System.SystemStatus.ACTIVE, name=SYSTEM_ONE_NAME, agencies=views.AgenciesInSystem(count=SYSTEM_ONE_NUM_AGENCIES, _system_id=SYSTEM_ONE_ID), stops=views.StopsInSystem(count=SYSTEM_ONE_NUM_STOPS, _system_id=SYSTEM_ONE_ID), routes=views.RoutesInSystem(count=SYSTEM_ONE_NUM_ROUTES, _system_id=SYSTEM_ONE_ID), feeds=views.FeedsInSystem(count=SYSTEM_ONE_NUM_FEEDS, _system_id=SYSTEM_ONE_ID), transfers=views.TransfersInSystem(count=SYSTEM_ONE_NUM_TRANSFERS, _system_id=SYSTEM_ONE_ID), ) monkeypatch.setattr(systemqueries, "get_by_id", lambda *args: system) monkeypatch.setattr(genericqueries, "count_number_of_related_entities", count) actual = systemservice.get_by_id(SYSTEM_ONE_ID) assert expected == actual
def test_list_all(monkeypatch): monkeypatch.setattr( systemqueries, "list_all", lambda: [ models.System( id=SYSTEM_ONE_ID, name=SYSTEM_ONE_NAME, status=models.System.SystemStatus.ACTIVE, ) ], ) expected = [ views.System( id=SYSTEM_ONE_ID, name=SYSTEM_ONE_NAME, status=models.System.SystemStatus.ACTIVE, ) ] actual = systemservice.list_all() assert expected == actual
def _create_system_update(system_id, config_str, extra_settings, config_source_url): system = systemqueries.get_by_id(system_id) if system is not None: invalid_statuses_for_update = { models.System.SystemStatus.SCHEDULED, models.System.SystemStatus.INSTALLING, models.System.SystemStatus.DELETING, } if system.status in invalid_statuses_for_update: raise exceptions.InstallError( "Cannot install or update system with status '{}'. " "If the system is stuck in this state, delete it first to reinstall".format( system.status.name ) ) elif system.status == models.System.SystemStatus.INSTALL_FAILED: system.status = models.System.SystemStatus.SCHEDULED else: system = models.System( id=system_id, name="(Awaiting install for full name)", status=models.System.SystemStatus.SCHEDULED, ) systemqueries.create(system) update = models.SystemUpdate( system=system, status=models.SystemUpdate.Status.SCHEDULED, config_template=config_str, config_parameters=json.dumps(extra_settings, indent=2), config_source_url=config_source_url, transiter_version=__metadata__.__version__, ) dbconnection.get_session().add(update) dbconnection.get_session().flush() return update.pk
import pytest from transiter import exceptions from transiter.db import models from transiter.db.queries import stopqueries, systemqueries, transfersconfigqueries from transiter.services import transfersconfigservice, views SYSTEM_1_ID = "1" SYSTEM_2_ID = "2" STOP_1_ID = "3" STOP_2_ID = "4" STOP_3_ID = "5" SYSTEM_1 = models.System(id=SYSTEM_1_ID) SYSTEM_2 = models.System(id=SYSTEM_2_ID) def list_all_in_system_factory(stops): return lambda system_id: [ stop for stop in stops if stop.system.id == system_id ] # TODO: test that the transfers are returned ion sorted order @pytest.mark.parametrize( "stops,distance,expected_tuples", [ [ # Base case [ models.Stop(
def test_get_in_system_by_id(monkeypatch): stop_one = models.Stop( pk=STOP_ONE_PK, id=STOP_ONE_ID, system=models.System(id=SYSTEM_ID), ) stop_time_one = models.TripStopTime( pk=TRIP_STOP_TIME_ONE_PK, arrival_time=datetime.datetime(2000, 1, 1, 0, 0, 0), ) stop_time_two = models.TripStopTime( pk=TRIP_STOP_TIME_TWO_PK, arrival_time=datetime.datetime(2137, 1, 1, 0, 0, 0), ) child_stops = mock.MagicMock() parent_stop = mock.MagicMock() monkeypatch.setattr(stopqueries, "get_in_system_by_id", lambda *args: stop_one) monkeypatch.setattr(stopqueries, "list_all_transfers_at_stops", lambda *args: []) monkeypatch.setattr(stopqueries, "list_all_stops_in_stop_tree", lambda *args: [stop_one]) monkeypatch.setattr(stopqueries, "list_direction_rules_for_stops", lambda *args: []) monkeypatch.setattr( stopqueries, "list_stop_time_updates_at_stops", lambda *args, **kwargs: [stop_time_one, stop_time_two], ) monkeypatch.setattr(tripqueries, "get_trip_pk_to_last_stop_map", mock.MagicMock()) monkeypatch.setattr(servicemapmanager, "build_stop_pk_to_service_maps_response", mock.MagicMock()) monkeypatch.setattr(stopservice._DirectionNameMatcher, "match", lambda *args: DIRECTION_NAME) monkeypatch.setattr(stopservice._DirectionNameMatcher, "all_names", lambda *args: [DIRECTION_NAME]) fake_stop_tree_response = views.Stop( id=STOP_TWO_ID, name=None, _system_id=SYSTEM_ID, child_stops=child_stops, parent_stop=parent_stop, ) monkeypatch.setattr(stopservice, "_build_stop_tree_response", lambda *args: fake_stop_tree_response) fake_trip_stop_time_response = mock.MagicMock() monkeypatch.setattr( stopservice, "_build_trip_stop_time_response", lambda *args: fake_trip_stop_time_response, ) monkeypatch.setattr( alertqueries, "get_stop_pk_to_active_alerts", lambda *args, **kwargs: {STOP_ONE_PK: []}, ) expected = views.StopLarge( id=STOP_ONE_ID, name=None, latitude=None, longitude=None, url=None, _system_id=SYSTEM_ID, parent_stop=parent_stop, child_stops=child_stops, directions=[DIRECTION_NAME], stop_times=[fake_trip_stop_time_response], alerts=[], transfers=[], ) actual = stopservice.get_in_system_by_id(SYSTEM_ID, STOP_ONE_ID, exclude_trips_before=1) assert expected == actual
def system_1(add_model): return add_model( models.System( pk=1, id="2", status=models.System.SystemStatus.ACTIVE, name="System 1" ) )
def installing_system(add_model): return add_model( models.System( pk=5, id="6", status=models.System.SystemStatus.INSTALLING, name="System 3" ) )
def system_2(add_model): return add_model( models.System( pk=3, id="4", status=models.System.SystemStatus.ACTIVE, name="System 2" ) )
def test_save_feed_configuration(monkeypatch, session_factory): session = session_factory() monkeypatch.setattr(dbconnection, "get_session", lambda: session) monkeypatch.setattr( genericqueries, "get_id_to_pk_map", lambda *args: { FEED_ID_1: FEED_PK_1, FEED_ID_2: FEED_PK_2 }, ) system = models.System() feeds_config = { FEED_ID_2: { "parser": { "built_in": "GTFS_STATIC" }, "http": { "url": "https://demo.transiter.dev", "headers": {}, "timeout": 40 }, "auto_update": { "period": None, "enabled": False }, "required_for_install": True, }, FEED_ID_3: { "parser": { "custom": "a:b" }, "http": { "url": "https://nytimes.com", "headers": { "key": "value" } }, "auto_update": { "period": 5, "enabled": True }, "required_for_install": False, }, } expected_feed_1 = models.Feed( pk=FEED_PK_2, id=FEED_ID_2, built_in_parser="GTFS_STATIC", custom_parser=None, url="https://demo.transiter.dev", headers="{}", http_timeout=40, parser_options=None, auto_update_enabled=False, auto_update_period=None, required_for_install=True, ) expected_feed_2 = models.Feed( id=FEED_ID_3, built_in_parser=None, custom_parser="a:b", url="https://nytimes.com", headers=json.dumps({"key": "value"}, indent=2), parser_options=None, auto_update_period=5, auto_update_enabled=True, required_for_install=False, ) feed_ids_to_update, feed_ids_to_delete = systemservice._save_feed_configuration( system, feeds_config) assert feed_ids_to_update == [FEED_ID_2] assert feed_ids_to_delete == [FEED_ID_1] assert [expected_feed_1, expected_feed_2] == session.merged
def create(self, system=None): if system is None: self._system = models.System() else: self._system = system return self._system