diet-guard/app/test/models/meal_schedule_test.dart

/// Tests for the pure meal-schedule derivation.
///
/// The cross-language exact values live in the shared fixture
/// `tests/fixtures/meal_schedule_vectors.json`, asserted by
/// `meal_schedule_vectors_test.dart` (and by its Python mirror). This file
/// holds the properties: the grid sweep, the hour-formula regression and the
/// clamps a human should read without opening the fixture. The sweeps are
/// duplicated loop-for-loop in `diet_guard/tests/test_meal_schedule.py`.
library;

import 'package:diet_guard_app/models/meal_schedule.dart';
import 'package:flutter_test/flutter_test.dart';

const int _h = 60;

/// The pre-minute whole-hour derivation, converted to minutes.
List<int> _oldHourSlots(int first, int last, int count) {
  final span = last - first;
  final divisions = count - 1;
  return [
    for (var index = 0; index < count; index++)
      (first + (index * span + divisions ~/ 2) ~/ divisions) * _h,
  ];
}

bool _strictlyAscending(List<int> slots) {
  for (var i = 1; i < slots.length; i++) {
    if (slots[i - 1] >= slots[i]) return false;
  }
  return true;
}

MealSchedule _s(int first, int last, int count) =>
    MealSchedule(firstMinute: first, lastMinute: last, count: count);

void main() {
  group('slots', () {
    test('the default is the historical schedule', () {
      expect(kDefaultSchedule.slots(), [480, 720, 960, 1200]);
    });

    // Upgrading must not move a checkpoint for the schedules people actually
    // have, or every existing hour-tagged entry would satisfy a neighbour.
    for (final (first, last, count) in const [
      (8, 20, 4),
      (8, 20, 5),
      (7, 19, 5),
    ]) {
      test('$first-$last x$count matches the old hour formula', () {
        expect(
          _s(first * _h, last * _h, count).slots(),
          _oldHourSlots(first, last, count),
        );
      });
    }

    test('off-grid endpoints are exact; only the interior snaps', () {
      final slots = _s(443, 1181, 5).slots();
      expect(slots.first, 443);
      expect(slots.last, 1181);
      for (final slot in slots.sublist(1, slots.length - 1)) {
        expect(slot % kSlotGridMinutes, 0);
      }
    });

    test("the user's quarter-hour schedule", () {
      expect(_s(435, 1140, 5).slots(), [435, 615, 795, 960, 1140]);
    });
  });

  group('normalized', () {
    final cases = <(MealSchedule, MealSchedule)>[
      (_s(480, 1200, 99), _s(480, 1200, kMaxMealCount)),
      (_s(480, 1200, 0), _s(480, 1200, kMinMealCount)),
      (_s(-5, 1200, 4), _s(0, 1200, 4)),
      (_s(480, 9999, 4), _s(480, 1439, 4)),
      // last <= first is pulled forward to leave one grid step of window.
      (_s(720, 720, 4), _s(720, 735, 2)),
      (_s(720, 3, 4), _s(720, 735, 2)),
      // first cannot sit in the final grid step, or no window remains.
      (_s(1439, 1439, 2), _s(1424, 1439, 2)),
      // Count is capped by the grid: 60 minutes hold 5 quarter-hour marks.
      (_s(480, 540, 6), _s(480, 540, 5)),
    ];
    for (final (input, expected) in cases) {
      test('$input clamps to $expected', () {
        expect(input.normalized(), expected);
      });
    }

    test('garbage still yields usable slots', () {
      expect(_s(9999, -5, 999).slots(), [1424, 1439]);
    });
  });

  group('enforcementEndMinute', () {
    test('the default keeps the historical 22:00 cutoff', () {
      expect(kDefaultSchedule.enforcementEndMinute, 22 * _h);
    });

    test('the tail follows the last meal, to the minute', () {
      expect(_s(480, 1095, 4).enforcementEndMinute, 1215);
    });

    test('is clamped to the end of the day', () {
      // An unclamped 1380 + 120 = 1500 would make `minute < cutoff`
      // vacuously true, so the enforcement window would never close.
      expect(_s(480, 1380, 4).enforcementEndMinute, kMinutesPerDay);
    });

    test('follows the normalised last meal', () {
      final schedule = _s(720, 3, 4);
      expect(schedule.enforcementEndMinute, schedule.slots().last + 120);
    });
  });

  group('wire', () {
    test('a whole-hour schedule encodes exactly as before', () {
      expect(scheduleToWire(kDefaultSchedule), {'f': 8, 'l': 20, 'n': 4});
    });

    test('off-hour endpoints add minute fields', () {
      expect(scheduleToWire(_s(435, 1181, 5)), {
        'f': 7,
        'l': 19,
        'n': 5,
        'fm': 435,
        'lm': 1181,
      });
    });

    test('unusable values decode to null', () {
      expect(scheduleFromWire({'f': true, 'l': 20, 'n': 4}), isNull);
      expect(scheduleFromWire('not a map'), isNull);
    });
  });

  test('grid sweep yields ascending slots with exact endpoints', () {
    // The Python mirror runs the identical loop. A wire round trip rides
    // along, because it is the same sweep's worth of schedules. Plain checks
    // with `fail` rather than `expect` per cell keep 46k cells fast.
    for (var first = 0; first < kMinutesPerDay; first += kSlotGridMinutes) {
      for (var last = 0; last < kMinutesPerDay; last += kSlotGridMinutes) {
        for (var count = kMinMealCount; count <= kMaxMealCount; count++) {
          final schedule = _s(first, last, count);
          final normalized = schedule.normalized();
          final slots = schedule.slots();
          final ok =
              slots.first == normalized.firstMinute &&
              slots.last == normalized.lastMinute &&
              slots.length == normalized.count &&
              _strictlyAscending(slots) &&
              slots.first >= 0 &&
              slots.last < kMinutesPerDay &&
              scheduleFromWire(scheduleToWire(schedule)) == normalized;
          if (!ok) fail('$schedule derived $slots');
        }
      }
    }
  });

  test('off-grid sweep stays strictly ascending', () {
    for (var first = 0; first < 120; first += 7) {
      for (var width = 15; width < 200; width += 11) {
        for (var count = kMinMealCount; count <= kMaxMealCount; count++) {
          final slots = _s(first, first + width, count).slots();
          if (!_strictlyAscending(slots)) fail('$first+$width x$count: $slots');
        }
      }
    }
  });
}