add edge case coverage for decoder pipeline and utility helpers

Author: jakobkoerber

test/eatApi/cafeteria_test.dart

@@ -0,0 +1,181 @@
+import 'dart:convert';
+
+import 'package:campus_flutter/placesComponent/model/cafeterias/cafeteria.dart';
+import 'package:campus_flutter/placesComponent/model/cafeterias/dish.dart';
+import 'package:campus_flutter/placesComponent/model/cafeterias/meal_plan.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  Map<String, dynamic> j(String s) => jsonDecode(s) as Map<String, dynamic>;
+
+  group('Cafeteria JSON decoding', () {
+    test('decodes a full cafeteria with opening hours', () {
+      final json = j('''
+{
+  "location": {
+    "latitude": 48.14735,
+    "longitude": 11.56774,
+    "address": "Arcisstraße 17, 80333 München"
+  },
+  "name": "Mensa Arcisstraße",
+  "canteen_id": "mensa-arcisstr",
+  "queue_status": "low",
+  "open_hours": {
+    "mon": {"start": "11:00", "end": "14:00"},
+    "tue": {"start": "11:00", "end": "14:00"},
+    "wed": {"start": "11:00", "end": "14:00"},
+    "thu": {"start": "11:00", "end": "14:00"},
+    "fri": {"start": "11:00", "end": "13:30"}
+  }
+}
+''');
+      final cafeteria = Cafeteria.fromJson(json);
+
+      expect(cafeteria.name, 'Mensa Arcisstraße');
+      expect(cafeteria.id, 'mensa-arcisstr');
+      expect(cafeteria.queueStatusApi, 'low');
+      expect(cafeteria.location.latitude, closeTo(48.14735, 0.0001));
+      expect(cafeteria.location.longitude, closeTo(11.56774, 0.0001));
+      expect(cafeteria.location.address, 'Arcisstraße 17, 80333 München');
+
+      expect(cafeteria.openingHours, isNotNull);
+      expect(cafeteria.openingHours!.mon?.start, '11:00');
+      expect(cafeteria.openingHours!.fri?.end, '13:30');
+
+      // Weekdays 1–5 all return (true, OpeningHour)
+      // 2024-04-15 Mon, 2024-04-16 Tue … 2024-04-19 Fri, 2024-04-20 Sat
+      expect(cafeteria.openingHoursForDate(DateTime(2024, 4, 15)).$1, isTrue); // Monday
+      expect(cafeteria.openingHoursForDate(DateTime(2024, 4, 16)).$1, isTrue); // Tuesday
+      expect(cafeteria.openingHoursForDate(DateTime(2024, 4, 17)).$1, isTrue); // Wednesday
+      expect(cafeteria.openingHoursForDate(DateTime(2024, 4, 18)).$1, isTrue); // Thursday
+      expect(cafeteria.openingHoursForDate(DateTime(2024, 4, 19)).$1, isTrue); // Friday
+      expect(cafeteria.openingHoursForDate(DateTime(2024, 4, 20)).$1, isFalse); // Saturday
+      expect(cafeteria.openingHoursForDate(DateTime(2024, 4, 21)).$1, isFalse); // Sunday
+      // null date → default case
+      expect(cafeteria.openingHoursForDate(null).$1, isFalse);
+    });
+
+    test('decodes a cafeteria without optional opening hours', () {
+      final json = j('''
+{
+  "location": {"latitude": 48.265, "longitude": 11.668, "address": "Boltzmannstraße 15, 85748 Garching"},
+  "name": "StuBistro Garching",
+  "canteen_id": "stubistro-garching",
+  "queue_status": null
+}
+''');
+      final cafeteria = Cafeteria.fromJson(json);
+
+      expect(cafeteria.openingHours, isNull);
+      expect(cafeteria.queueStatusApi, isNull);
+    });
+
+    test('Cafeterias wrapper decodes list from "data" key', () {
+      final json = j('''
+{
+  "data": [
+    {
+      "location": {"latitude": 48.14735, "longitude": 11.56774, "address": "Arcisstraße 17"},
+      "name": "Mensa Arcisstraße",
+      "canteen_id": "mensa-arcisstr",
+      "queue_status": null
+    },
+    {
+      "location": {"latitude": 48.265, "longitude": 11.668, "address": "Boltzmannstraße 15"},
+      "name": "StuBistro Garching",
+      "canteen_id": "stubistro-garching",
+      "queue_status": null
+    }
+  ]
+}
+''');
+      final cafeterias = Cafeterias.fromJson(json);
+
+      expect(cafeterias.cafeterias.length, 2);
+      expect(cafeterias.cafeterias[0].id, 'mensa-arcisstr');
+      expect(cafeterias.cafeterias[1].id, 'stubistro-garching');
+    });
+  });
+
+  group('Dish JSON decoding', () {
+    test('decodes a dish with prices and labels', () {
+      final json = j('''
+{
+  "name": "Schnitzel mit Pommes",
+  "prices": {
+    "students": {"base_price": 2.50, "price_per_unit": null, "unit": null},
+    "staff":    {"base_price": 4.00, "price_per_unit": null, "unit": null}
+  },
+  "labels": ["veal", "gluten"],
+  "dish_type": "Hauptspeise"
+}
+''');
+      final dish = Dish.fromJson(json);
+
+      expect(dish.name, 'Schnitzel mit Pommes');
+      expect(dish.dishType, 'Hauptspeise');
+      expect(dish.labels, containsAll(['veal', 'gluten']));
+      expect(dish.prices['students']?.basePrice, closeTo(2.50, 0.001));
+      expect(dish.prices['staff']?.basePrice, closeTo(4.00, 0.001));
+    });
+
+    test('decodes a dish with no labels', () {
+      final json = j('''
+{
+  "name": "Apfelschorle",
+  "prices": {},
+  "labels": [],
+  "dish_type": "Beilage"
+}
+''');
+      final dish = Dish.fromJson(json);
+
+      expect(dish.labels, isEmpty);
+      expect(dish.prices, isEmpty);
+    });
+  });
+
+  group('MealPlan / MensaMenu JSON decoding', () {
+    test('decodes a weekly meal plan with multiple days', () {
+      final json = j('''
+{
+  "number": 16,
+  "year": 2024,
+  "days": [
+    {
+      "date": "2024-04-15",
+      "dishes": [
+        {
+          "name": "Pasta",
+          "prices": {"students": {"base_price": 1.80}},
+          "labels": ["vegan"],
+          "dish_type": "Hauptspeise"
+        }
+      ]
+    },
+    {
+      "date": "2024-04-16",
+      "dishes": []
+    }
+  ]
+}
+''');
+      final plan = MealPlan.fromJson(json);
+
+      expect(plan.week, 16);
+      expect(plan.year, 2024);
+      expect(plan.days.length, 2);
+      expect(plan.days[0].date, DateTime.parse('2024-04-15'));
+      expect(plan.days[0].dishes.length, 1);
+      expect(plan.days[0].dishes[0].name, 'Pasta');
+      expect(plan.days[1].dishes, isEmpty);
+    });
+
+    test('decodes an empty meal plan', () {
+      final json = j('{"number": 1, "year": 2024, "days": []}');
+      final plan = MealPlan.fromJson(json);
+
+      expect(plan.days, isEmpty);
+    });
+  });
+}

test/helpers/api_response_test.dart

@@ -0,0 +1,77 @@
+import 'dart:convert';
+
+import 'package:campus_flutter/base/networking/base/api_response.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('ApiResponse.fromJson', () {
+    test('decodes when root JSON is a Map', () {
+      final json = jsonDecode('{"name": "Test", "value": 42}');
+      final extras = <String, dynamic>{};
+
+      final response = ApiResponse<Map<String, dynamic>>.fromJson(
+        json,
+        extras,
+        (j) => j,
+      );
+
+      expect(response.data['name'], 'Test');
+      expect(response.data['value'], 42);
+      expect(response.saved, isNull);
+    });
+
+    test('wraps root JSON List in {"data": [...]} before calling create', () {
+      final json = jsonDecode('[{"id": 1}, {"id": 2}]');
+      final extras = <String, dynamic>{};
+
+      final response = ApiResponse<List<dynamic>>.fromJson(
+        json,
+        extras,
+        (j) => j['data'] as List<dynamic>,
+      );
+
+      expect(response.data.length, 2);
+      expect((response.data[0] as Map)['id'], 1);
+    });
+
+    test('threads "saved" DateTime through from extras', () {
+      final savedAt = DateTime(2024, 4, 15, 10, 0, 0);
+      final json = jsonDecode('{"key": "value"}');
+      final extras = <String, dynamic>{'saved': savedAt};
+
+      final response = ApiResponse<Map<String, dynamic>>.fromJson(
+        json,
+        extras,
+        (j) => j,
+      );
+
+      expect(response.saved, savedAt);
+    });
+
+    test('saved is null when not present in extras', () {
+      final json = jsonDecode('{"key": "value"}');
+      final extras = <String, dynamic>{};
+
+      final response = ApiResponse<Map<String, dynamic>>.fromJson(
+        json,
+        extras,
+        (j) => j,
+      );
+
+      expect(response.saved, isNull);
+    });
+
+    test('passes decoded data through the create function', () {
+      final json = jsonDecode('{"count": "5"}');
+      final extras = <String, dynamic>{};
+
+      final response = ApiResponse<int>.fromJson(
+        json,
+        extras,
+        (j) => int.parse(j['count'] as String),
+      );
+
+      expect(response.data, 5);
+    });
+  });
+}

test/helpers/read_list_value_test.dart

@@ -0,0 +1,46 @@
+import 'package:campus_flutter/base/util/read_list_value.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('readListValue', () {
+    test('returns empty list when key is absent', () {
+      final result = readListValue({'other': 'value'}, 'location');
+      expect(result, isEmpty);
+    });
+
+    test('returns empty list when value is null', () {
+      final result = readListValue({'location': null}, 'location');
+      expect(result, isEmpty);
+    });
+
+    test('passes a List through unchanged', () {
+      final result = readListValue({
+        'location': ['Room A', 'Room B'],
+      }, 'location');
+      expect(result, ['Room A', 'Room B']);
+    });
+
+    test('wraps a String in a list', () {
+      final result = readListValue({'location': 'Room A'}, 'location');
+      expect(result, ['Room A']);
+    });
+
+    test('wraps a Map in a list', () {
+      final map = {'nummer': '001', 'gebaeude': 'MI'};
+      final result = readListValue({'raum': map}, 'raum');
+      expect(result, [map]);
+    });
+
+    test('returns empty list for numeric value (unrecognised type)', () {
+      final result = readListValue({'count': 42}, 'count');
+      expect(result, isEmpty);
+    });
+
+    test('preserves list with mixed-type entries', () {
+      final result = readListValue({
+        'items': ['a', 'b', 'c'],
+      }, 'items');
+      expect(result.length, 3);
+    });
+  });
+}

test/helpers/string_parser_test.dart

@@ -0,0 +1,91 @@
+import 'package:campus_flutter/base/util/string_parser.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('StringParser.stringToDouble', () {
+    test('parses dot-decimal string', () {
+      expect(StringParser.stringToDouble('1.7'), closeTo(1.7, 0.001));
+    });
+
+    test('parses comma-decimal string (German format)', () {
+      expect(StringParser.stringToDouble('1,7'), closeTo(1.7, 0.001));
+    });
+
+    test('parses integer string as double', () {
+      expect(StringParser.stringToDouble('2'), closeTo(2.0, 0.001));
+    });
+
+    test('returns null for null input', () {
+      expect(StringParser.stringToDouble(null), isNull);
+    });
+
+    test('returns null for non-parseable string (e.g. "n.b.")', () {
+      // "nicht benotet" — a real TUM grade value meaning "not yet graded"
+      expect(StringParser.stringToDouble('n.b.'), isNull);
+    });
+
+    test('returns null for empty string', () {
+      // API can return an empty element <soll/> that xml2json converts to ""
+      expect(StringParser.stringToDouble(''), isNull);
+    });
+
+    test('parses zero', () {
+      expect(StringParser.stringToDouble('0,00'), closeTo(0.0, 0.001));
+    });
+
+    test('parses tuition amount with comma', () {
+      expect(StringParser.stringToDouble('117,10'), closeTo(117.10, 0.001));
+    });
+  });
+
+  group('StringParser.stringToInt', () {
+    test('parses a valid integer string', () {
+      expect(StringParser.stringToInt('42'), 42);
+    });
+
+    test('returns 0 for null input', () {
+      expect(StringParser.stringToInt(null), 0);
+    });
+
+    test('returns 0 for non-integer string', () {
+      // e.g. org_nr fields can occasionally be malformed
+      expect(StringParser.stringToInt('abc'), 0);
+    });
+
+    test('returns 0 for empty string', () {
+      expect(StringParser.stringToInt(''), 0);
+    });
+
+    test('parses large ID numbers', () {
+      expect(StringParser.stringToInt('950000001'), 950000001);
+    });
+  });
+
+  group('StringParser.optStringToOptInt', () {
+    test('parses a valid integer string', () {
+      expect(StringParser.optStringToOptInt('5'), 5);
+    });
+
+    test('returns null for null input', () {
+      expect(StringParser.optStringToOptInt(null), isNull);
+    });
+
+    test('returns null for non-integer string', () {
+      expect(StringParser.optStringToOptInt('abc'), isNull);
+    });
+
+    test('returns null for empty string', () {
+      expect(StringParser.optStringToOptInt(''), isNull);
+    });
+  });
+
+  group('StringParser.optStringToOptDouble', () {
+    test('parses a comma-decimal string', () {
+      expect(StringParser.optStringToOptDouble('2,3'), closeTo(2.3, 0.001));
+    });
+
+    test('returns null for null input', () {
+      expect(StringParser.optStringToOptDouble(null), isNull);
+    });
+  });
+}