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