400 lines
16 KiB
Dart
400 lines
16 KiB
Dart
import 'dart:convert';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:http/testing.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
import 'package:motorcycle_dash/services/alerts/road_alert_models.dart';
|
|
import 'package:motorcycle_dash/services/alerts/waze_road_alert_provider.dart';
|
|
import 'package:motorcycle_dash/services/alerts/road_alert_providers.dart';
|
|
|
|
void main() {
|
|
TestWidgetsFlutterBinding.ensureInitialized();
|
|
|
|
setUp(() async {
|
|
SharedPreferences.setMockInitialValues({});
|
|
});
|
|
|
|
group('WazeRoadAlertProvider Metadata Tests', () {
|
|
test('provider has correct id, name, and supported categories', () {
|
|
final provider = WazeRoadAlertProvider();
|
|
expect(provider.id, equals('waze'));
|
|
expect(provider.name, equals('Waze Police Alerts'));
|
|
expect(
|
|
provider.supportedCategories,
|
|
equals({RoadAlertCategory.police}),
|
|
);
|
|
});
|
|
});
|
|
|
|
group('WazeRoadAlertProvider Connection Tests', () {
|
|
test('testConnection returns notConfigured for empty or whitespace key', () async {
|
|
final provider = WazeRoadAlertProvider(apiHost: 'waze-proxy.internal');
|
|
expect(await provider.testConnection(''), equals(RoadAlertProviderStatus.notConfigured));
|
|
expect(await provider.testConnection(' '), equals(RoadAlertProviderStatus.notConfigured));
|
|
});
|
|
|
|
test('testConnection returns connected on HTTP 200 with required headers and params', () async {
|
|
final mockClient = MockClient((request) async {
|
|
expect(request.url.host, equals('waze-proxy.internal'));
|
|
expect(request.url.path, equals('/waze/alerts-and-jams'));
|
|
expect(request.headers['x-api-key'], equals('test_waze_key'));
|
|
expect(request.url.queryParameters['center'], equals('34.0522,-118.2437'));
|
|
expect(request.url.queryParameters['radius_units'], equals('KM'));
|
|
expect(request.url.queryParameters['max_alerts'], equals('1'));
|
|
expect(request.url.queryParameters['max_jams'], equals('0'));
|
|
expect(request.url.queryParameters['alert_types'], equals('POLICE'));
|
|
return http.Response(json.encode({'status': 'success', 'data': {'alerts': []}}), 200);
|
|
});
|
|
|
|
final provider = WazeRoadAlertProvider(client: mockClient, apiHost: 'waze-proxy.internal');
|
|
final status = await provider.testConnection('test_waze_key');
|
|
expect(status, equals(RoadAlertProviderStatus.connected));
|
|
});
|
|
|
|
test('testConnection returns authError on HTTP 401 or 403', () async {
|
|
final mockClient401 = MockClient((request) async {
|
|
return http.Response('{"message": "Unauthorized"}', 401);
|
|
});
|
|
final provider401 = WazeRoadAlertProvider(client: mockClient401, apiHost: 'waze-proxy.internal');
|
|
expect(await provider401.testConnection('bad_key'), equals(RoadAlertProviderStatus.authError));
|
|
|
|
final mockClient403 = MockClient((request) async {
|
|
return http.Response('{"message": "Forbidden"}', 403);
|
|
});
|
|
final provider403 = WazeRoadAlertProvider(client: mockClient403, apiHost: 'waze-proxy.internal');
|
|
expect(await provider403.testConnection('forbidden_key'), equals(RoadAlertProviderStatus.authError));
|
|
});
|
|
|
|
test('testConnection returns rateLimited on HTTP 429', () async {
|
|
final mockClient = MockClient((request) async {
|
|
return http.Response('{"message": "Too Many Requests"}', 429);
|
|
});
|
|
final provider = WazeRoadAlertProvider(client: mockClient, apiHost: 'waze-proxy.internal');
|
|
expect(await provider.testConnection('busy_key'), equals(RoadAlertProviderStatus.rateLimited));
|
|
});
|
|
|
|
test('testConnection returns networkError on HTTP 500 or network exception', () async {
|
|
final mockClient500 = MockClient((request) async {
|
|
return http.Response('{"message": "Internal Server Error"}', 500);
|
|
});
|
|
final provider500 = WazeRoadAlertProvider(client: mockClient500, apiHost: 'waze-proxy.internal');
|
|
expect(await provider500.testConnection('key'), equals(RoadAlertProviderStatus.networkError));
|
|
|
|
final mockClientException = MockClient((request) async {
|
|
throw http.ClientException('Connection reset by peer');
|
|
});
|
|
final providerEx = WazeRoadAlertProvider(client: mockClientException, apiHost: 'waze-proxy.internal');
|
|
expect(await providerEx.testConnection('key'), equals(RoadAlertProviderStatus.networkError));
|
|
});
|
|
});
|
|
|
|
group('WazeRoadAlertProvider Query & Parsing Tests', () {
|
|
test('getAlerts returns empty list if apiKey is null or empty', () async {
|
|
final provider = WazeRoadAlertProvider();
|
|
final r1 = await provider.getAlerts(
|
|
latitude: 34.05,
|
|
longitude: -118.25,
|
|
radiusMeters: 1000,
|
|
apiKey: null,
|
|
);
|
|
expect(r1, isEmpty);
|
|
|
|
final r2 = await provider.getAlerts(
|
|
latitude: 34.05,
|
|
longitude: -118.25,
|
|
radiusMeters: 1000,
|
|
apiKey: ' ',
|
|
);
|
|
expect(r2, isEmpty);
|
|
});
|
|
|
|
test('getAlerts enforces alert_types=POLICE, max_jams=0, and radius_units=KM', () async {
|
|
final mockClient = MockClient((request) async {
|
|
expect(request.url.host, equals('waze-proxy.internal'));
|
|
expect(request.url.path, equals('/waze/alerts-and-jams'));
|
|
expect(request.headers['x-api-key'], equals('custom_key_123'));
|
|
expect(request.url.queryParameters['center'], equals('37.7749,-122.4194'));
|
|
expect(request.url.queryParameters['radius'], equals('2.5'));
|
|
expect(request.url.queryParameters['radius_units'], equals('KM'));
|
|
expect(request.url.queryParameters['max_alerts'], equals('25'));
|
|
expect(request.url.queryParameters['max_jams'], equals('0'));
|
|
expect(request.url.queryParameters['alert_types'], equals('POLICE'));
|
|
|
|
return http.Response(
|
|
json.encode({
|
|
'status': 'success',
|
|
'data': {
|
|
'alerts': [
|
|
{
|
|
'alert_id': '101',
|
|
'type': 'POLICE',
|
|
'subtype': 'POLICE_VISIBLE',
|
|
'latitude': 37.775,
|
|
'longitude': -122.419,
|
|
'street': 'Market St',
|
|
'city': 'San Francisco, CA',
|
|
'publish_datetime_utc': '2026-09-26T18:00:00.000Z',
|
|
'alert_confidence': 5,
|
|
'alert_reliability': 8,
|
|
'num_thumbs_up': 4,
|
|
},
|
|
{
|
|
'alert_id': '102',
|
|
'type': 'POLICE',
|
|
'subtype': 'POLICE_HIDDEN',
|
|
'latitude': 37.778,
|
|
'longitude': -122.421,
|
|
'street': 'Mission St',
|
|
'city': 'San Francisco, CA',
|
|
'publish_datetime_utc': '2026-09-26T18:05:00.000Z',
|
|
'alert_confidence': 4,
|
|
'alert_reliability': 7,
|
|
'num_thumbs_up': 1,
|
|
},
|
|
// Unrelated category that must be strictly discarded
|
|
{
|
|
'alert_id': '999',
|
|
'type': 'HAZARD',
|
|
'subtype': 'HAZARD_ON_SHOULDER',
|
|
'latitude': 37.780,
|
|
'longitude': -122.425,
|
|
}
|
|
]
|
|
}
|
|
}),
|
|
200,
|
|
);
|
|
});
|
|
|
|
final provider = WazeRoadAlertProvider(client: mockClient, apiHost: 'waze-proxy.internal');
|
|
final alerts = await provider.getAlerts(
|
|
latitude: 37.7749,
|
|
longitude: -122.4194,
|
|
radiusMeters: 2500,
|
|
apiKey: 'custom_key_123',
|
|
);
|
|
|
|
// Only the 2 police alerts are parsed; hazard is strictly dropped
|
|
expect(alerts.length, equals(2));
|
|
|
|
final visibleTrap = alerts[0];
|
|
expect(visibleTrap.id, equals('waze_101'));
|
|
expect(visibleTrap.category, equals(RoadAlertCategory.police));
|
|
expect(visibleTrap.severity, equals(RoadAlertSeverity.medium));
|
|
expect(visibleTrap.description, contains('Police speed trap reported on Market St'));
|
|
expect(visibleTrap.roadName, equals('Market St, San Francisco, CA'));
|
|
expect(visibleTrap.source, equals('Waze'));
|
|
|
|
final hiddenTrap = alerts[1];
|
|
expect(hiddenTrap.id, equals('waze_102'));
|
|
expect(hiddenTrap.category, equals(RoadAlertCategory.police));
|
|
expect(hiddenTrap.severity, equals(RoadAlertSeverity.high));
|
|
expect(hiddenTrap.description, contains('Hidden police speed trap reported on Mission St'));
|
|
});
|
|
|
|
test('parseWazeItem strictly rejects non-POLICE alerts', () {
|
|
final provider = WazeRoadAlertProvider();
|
|
expect(
|
|
provider.parseWazeItem({
|
|
'alert_id': '1',
|
|
'type': 'ACCIDENT',
|
|
'latitude': 34.0,
|
|
'longitude': -118.0,
|
|
}),
|
|
isNull,
|
|
);
|
|
expect(
|
|
provider.parseWazeItem({
|
|
'alert_id': '2',
|
|
'type': 'JAM',
|
|
'latitude': 34.0,
|
|
'longitude': -118.0,
|
|
}),
|
|
isNull,
|
|
);
|
|
expect(
|
|
provider.parseWazeItem({
|
|
'alert_id': '3',
|
|
'type': 'HAZARD',
|
|
'latitude': 34.0,
|
|
'longitude': -118.0,
|
|
}),
|
|
isNull,
|
|
);
|
|
expect(
|
|
provider.parseWazeItem({
|
|
'alert_id': '4',
|
|
'type': 'ROAD_CLOSED',
|
|
'latitude': 34.0,
|
|
'longitude': -118.0,
|
|
}),
|
|
isNull,
|
|
);
|
|
});
|
|
|
|
test('parseWazeItem handles missing street or generic subtype smoothly', () {
|
|
final provider = WazeRoadAlertProvider();
|
|
final alert = provider.parseWazeItem({
|
|
'alert_id': '555',
|
|
'type': 'POLICE',
|
|
'latitude': 34.0522,
|
|
'longitude': -118.2437,
|
|
});
|
|
|
|
expect(alert, isNotNull);
|
|
expect(alert!.id, equals('waze_555'));
|
|
expect(alert.category, equals(RoadAlertCategory.police));
|
|
expect(alert.description, equals('Police reported in area'));
|
|
});
|
|
});
|
|
|
|
group('Riverpod Wiring for Waze Police Alerts Tests', () {
|
|
test('parseWazeItem handles POLICE_WITH_MOBILE_CAMERA subtype', () {
|
|
final provider = WazeRoadAlertProvider();
|
|
final alert = provider.parseWazeItem({
|
|
'alert_id': 'camera_123',
|
|
'type': 'POLICE',
|
|
'subtype': 'POLICE_WITH_MOBILE_CAMERA',
|
|
'latitude': 34.078,
|
|
'longitude': -118.266,
|
|
'street': 'Sunset Blvd',
|
|
'city': 'Los Angeles',
|
|
'num_thumbs_up': 25,
|
|
});
|
|
|
|
expect(alert, isNotNull);
|
|
expect(alert!.id, equals('waze_camera_123'));
|
|
expect(alert.category, equals(RoadAlertCategory.police));
|
|
expect(alert.severity, equals(RoadAlertSeverity.high));
|
|
expect(alert.description, equals('Police speed trap with camera reported on Sunset Blvd'));
|
|
expect(alert.roadName, equals('Sunset Blvd, Los Angeles'));
|
|
});
|
|
|
|
test('parseWazeItem handles POLICE_HIDING and POLICE_ON_OTHER_SIDE subtypes', () {
|
|
final provider = WazeRoadAlertProvider();
|
|
final hidingAlert = provider.parseWazeItem({
|
|
'alert_id': 'hiding_1',
|
|
'type': 'POLICE',
|
|
'subtype': 'POLICE_HIDING',
|
|
'latitude': 40.656,
|
|
'longitude': -74.009,
|
|
'street': '2nd Ave',
|
|
'city': 'New York',
|
|
});
|
|
expect(hidingAlert, isNotNull);
|
|
expect(hidingAlert!.severity, equals(RoadAlertSeverity.high));
|
|
expect(hidingAlert.description, contains('Hidden police speed trap reported on 2nd Ave'));
|
|
|
|
final otherSideAlert = provider.parseWazeItem({
|
|
'alert_id': 'side_2',
|
|
'type': 'POLICE',
|
|
'subtype': 'POLICE_ON_OTHER_SIDE',
|
|
'latitude': 40.658,
|
|
'longitude': -74.011,
|
|
'street': '3rd Ave',
|
|
});
|
|
expect(otherSideAlert, isNotNull);
|
|
expect(otherSideAlert!.severity, equals(RoadAlertSeverity.medium));
|
|
expect(otherSideAlert.description, contains('Police reported on opposite side of 3rd Ave'));
|
|
});
|
|
|
|
test('getAlertsInBoundingBox sends bottom_left and top_right with POLICE filter', () async {
|
|
final mockClient = MockClient((request) async {
|
|
expect(request.url.host, equals('waze-proxy.internal'));
|
|
expect(request.url.path, equals('/waze/alerts-and-jams'));
|
|
expect(request.headers['x-api-key'], equals('bbox_key'));
|
|
expect(request.url.queryParameters['bottom_left'], equals('40.6661,-74.1373'));
|
|
expect(request.url.queryParameters['top_right'], equals('40.7727,-73.7681'));
|
|
expect(request.url.queryParameters['max_alerts'], equals('15'));
|
|
expect(request.url.queryParameters['max_jams'], equals('0'));
|
|
expect(request.url.queryParameters['alert_types'], equals('POLICE'));
|
|
|
|
return http.Response(
|
|
json.encode({
|
|
'status': 'OK',
|
|
'data': {
|
|
'alerts': [
|
|
{
|
|
'alert_id': 'ny_trap_1',
|
|
'type': 'POLICE',
|
|
'subtype': 'POLICE_HIDING',
|
|
'latitude': 40.700,
|
|
'longitude': -73.950,
|
|
'street': 'FDR Drive',
|
|
}
|
|
]
|
|
}
|
|
}),
|
|
200,
|
|
);
|
|
});
|
|
|
|
final provider = WazeRoadAlertProvider(client: mockClient, apiHost: 'waze-proxy.internal');
|
|
final alerts = await provider.getAlertsInBoundingBox(
|
|
bottomLat: 40.6661,
|
|
bottomLng: -74.1373,
|
|
topLat: 40.7727,
|
|
topLng: -73.7681,
|
|
apiKey: 'bbox_key',
|
|
maxAlerts: 15,
|
|
);
|
|
|
|
expect(alerts.length, equals(1));
|
|
expect(alerts.first.id, equals('waze_ny_trap_1'));
|
|
expect(alerts.first.category, equals(RoadAlertCategory.police));
|
|
expect(alerts.first.severity, equals(RoadAlertSeverity.high));
|
|
});
|
|
|
|
test('wazeApiKeyProvider initializes with empty default and does not expose bundled key', () async {
|
|
final container = ProviderContainer();
|
|
addTearDown(container.dispose);
|
|
|
|
final initialKey = container.read(wazeApiKeyProvider);
|
|
expect(initialKey, isEmpty, reason: 'Bundled API key must not be present by default');
|
|
expect(initialKey, isNot(contains('ak_dud2s1987x5k7amfokrddptn41ov0iyf8kfdu3ljpv1fgvq')));
|
|
|
|
await container.read(wazeApiKeyProvider.notifier).setApiKey('custom_key_999');
|
|
expect(container.read(wazeApiKeyProvider), equals('custom_key_999'));
|
|
});
|
|
|
|
test('wazeRoadAlertsEnabledProvider defaults to true and toggles', () async {
|
|
final container = ProviderContainer();
|
|
addTearDown(container.dispose);
|
|
|
|
expect(container.read(wazeRoadAlertsEnabledProvider), isTrue);
|
|
|
|
await container.read(wazeRoadAlertsEnabledProvider.notifier).setEnabled(false);
|
|
expect(container.read(wazeRoadAlertsEnabledProvider), isFalse);
|
|
});
|
|
|
|
test('activeRoadAlertProviders excludes Waze when key is empty, includes when key is set', () async {
|
|
final container = ProviderContainer();
|
|
addTearDown(container.dispose);
|
|
|
|
// Initially no key, so Waze should not be active
|
|
var activeList = container.read(activeRoadAlertProviders);
|
|
expect(activeList.any((p) => p.id == 'waze'), isFalse);
|
|
|
|
// After user sets an API key, Waze should be active
|
|
await container.read(wazeApiKeyProvider.notifier).setApiKey('valid_test_key_123');
|
|
activeList = container.read(activeRoadAlertProviders);
|
|
expect(activeList.any((p) => p.id == 'waze'), isTrue);
|
|
});
|
|
|
|
test('WazeRoadAlertProvider uses custom apiHost if provided', () async {
|
|
final mockClient = MockClient((request) async {
|
|
expect(request.url.host, equals('custom-proxy.motorsignal.app'));
|
|
return http.Response('{"status":"success","data":{"alerts":[]}}', 200);
|
|
});
|
|
|
|
final provider = WazeRoadAlertProvider(
|
|
client: mockClient,
|
|
apiHost: 'custom-proxy.motorsignal.app',
|
|
);
|
|
final status = await provider.testConnection('test_key');
|
|
expect(status, equals(RoadAlertProviderStatus.connected));
|
|
});
|
|
});
|
|
}
|