// Table-driven mergeLogs() tests. `union by id` through `algebraic // properties` are the exact same assertions the pre-migration // `sync_merge.mergeLogs` had -- routed through `dayLogToLog -> // crdt_sync.mergeLogs -> logToDayLog` instead, to prove the migration // preserves the app's merge semantics exactly, mirroring // `test_sync_merge.py`'s equivalent Python-side proof. import 'dart:convert'; import 'package:crdt_sync/crdt_sync.dart'; import 'package:diet_guard_app/models/food_entry.dart'; import 'package:diet_guard_app/services/log_storage_service.dart'; import 'package:diet_guard_app/services/sync_merge.dart'; import 'package:flutter_test/flutter_test.dart'; FoodEntry _entry({ String? id = 'id-1', String time = '2026-06-22T08:00:00', String desc = 'oatmeal', bool deleted = false, }) => FoodEntry( id: id, time: time, desc: desc, grams: 200, kcal: 300, proteinG: 10, carbsG: 50, fatG: 5, source: 'manual', deleted: deleted, ); DayLog _mergeDaylogs(DayLog a, DayLog b) => logToDayLog(mergeLogs(dayLogToLog(a), dayLogToLog(b))); void main() { group('union by id', () { test('disjoint logs union into one', () { final a = { '2026-06-22': [_entry(id: 'a', time: '2026-06-22T08:00:00')], }; final b = { '2026-06-22': [_entry(id: 'b', time: '2026-06-22T12:00:00')], }; final merged = _mergeDaylogs(a, b); expect(merged['2026-06-22']!.map((e) => e.id).toSet(), {'a', 'b'}); }); test('same id in both logs is not duplicated', () { final shared = _entry(id: 'shared'); final merged = _mergeDaylogs( { '2026-06-22': [shared], }, { '2026-06-22': [shared], }, ); expect(merged['2026-06-22'], hasLength(1)); }); test('legacy entries without id dedup by time and desc', () { final legacyA = _entry( id: null, time: '2026-06-20T08:00:00', desc: 'toast', ); final legacyB = _entry( id: null, time: '2026-06-20T08:00:00', desc: 'toast', ); final merged = _mergeDaylogs( { '2026-06-20': [legacyA], }, { '2026-06-20': [legacyB], }, ); expect(merged['2026-06-20'], hasLength(1)); }); test('legacy and id entries with different keys both survive', () { final legacy = _entry( id: null, time: '2026-06-20T08:00:00', desc: 'toast', ); final withId = _entry(id: 'x', time: '2026-06-20T09:00:00', desc: 'eggs'); final merged = _mergeDaylogs( { '2026-06-20': [legacy], }, { '2026-06-20': [withId], }, ); expect(merged['2026-06-20'], hasLength(2)); }); }); group('tombstone wins', () { test('tombstone beats a non-deleted copy either order', () { final normal = _entry(id: 'x'); final tombstoned = _entry(id: 'x', deleted: true); final forward = _mergeDaylogs( { '2026-06-22': [normal], }, { '2026-06-22': [tombstoned], }, ); final backward = _mergeDaylogs( { '2026-06-22': [tombstoned], }, { '2026-06-22': [normal], }, ); expect(forward['2026-06-22']!.single.deleted, isTrue); expect(backward['2026-06-22']!.single.deleted, isTrue); }); test('two tombstoned copies stay tombstoned', () { final tombstoned = _entry(id: 'x', deleted: true); final merged = _mergeDaylogs( { '2026-06-22': [tombstoned], }, { '2026-06-22': [_entry(id: 'x', deleted: true)], }, ); expect(merged['2026-06-22']!.single.deleted, isTrue); }); }); group('rebucketing and ordering', () { test( "entry is filed under its own time's date, not the arrival bucket", () { final misfiled = _entry(id: 'x', time: '2026-06-21T23:00:00'); final merged = _mergeDaylogs({ '2026-06-22': [misfiled], }, {}); expect(merged.keys, ['2026-06-21']); expect(merged['2026-06-21']!.single.id, 'x'); }, ); test( 'an entry with a time shorter than a date key buckets under the ' 'raw time instead of crashing', () { final short = _entry(id: 'x', time: '2026'); final merged = _mergeDaylogs({ '2026-06-22': [short], }, {}); expect(merged.keys, ['2026']); }, ); test("a day's entries are sorted oldest-first", () { final late = _entry(id: 'late', time: '2026-06-22T20:00:00'); final early = _entry(id: 'early', time: '2026-06-22T08:00:00'); final merged = _mergeDaylogs( { '2026-06-22': [late], }, { '2026-06-22': [early], }, ); expect(merged['2026-06-22']!.map((e) => e.id).toList(), [ 'early', 'late', ]); }); }); group('algebraic properties', () { test('merge is commutative', () { final a = { '2026-06-22': [_entry(id: 'a')], }; final b = { '2026-06-22': [_entry(id: 'b', time: '2026-06-22T09:00:00')], }; final ab = _mergeDaylogs(a, b); final ba = _mergeDaylogs(b, a); expect( ab['2026-06-22']!.map((e) => e.id).toList(), ba['2026-06-22']!.map((e) => e.id).toList(), ); }); test('merge is idempotent', () { final canonical = { '2026-06-22': [_entry(id: 'a')], }; final merged = _mergeDaylogs(canonical, canonical); expect(merged['2026-06-22']!.map((e) => e.id).toList(), ['a']); }); test('merging with an empty log is a no-op', () { final log = { '2026-06-22': [_entry(id: 'a')], }; expect(_mergeDaylogs(log, {}).keys, log.keys); expect(_mergeDaylogs({}, log).keys, log.keys); }); test('merging two empty logs is empty', () { expect(_mergeDaylogs({}, {}), isEmpty); }); }); group('entryHlc', () { test('same entry always yields the same Hlc', () { expect(entryHlc(_entry()), entryHlc(_entry())); }); test('malformed time still yields a valid Hlc', () { expect(entryHlc(_entry(time: 'not-a-timestamp')).wallTimeMs, 0); }); }); group('legacyEntryId', () { test('same time and desc yields the same id', () { final a = _entry(time: '2026-06-20T08:00:00', desc: 'toast'); final b = _entry(time: '2026-06-20T08:00:00', desc: 'toast'); expect(legacyEntryId(a), legacyEntryId(b)); }); test('different desc yields a different id', () { final a = _entry(time: '2026-06-20T08:00:00', desc: 'toast'); final b = _entry(time: '2026-06-20T08:00:00', desc: 'eggs'); expect(legacyEntryId(a), isNot(legacyEntryId(b))); }); }); group('entry <-> Record round trip', () { test('round trip preserves all fields', () { final entry = _entry(id: 'x'); final roundTripped = recordToEntry(entryToRecord(entry)); expect(roundTripped.toSyncJson(), entry.toSyncJson()); }); test('round trip of a deleted entry preserves the tombstone', () { final entry = _entry(id: 'x', deleted: true); expect(recordToEntry(entryToRecord(entry)).deleted, isTrue); }); test('legacy entry gets a derived id on round trip', () { final entry = _entry( id: null, time: '2026-06-20T08:00:00', desc: 'toast', ); final roundTripped = recordToEntry(entryToRecord(entry)); expect(roundTripped.id, legacyEntryId(entry)); }); test('a Record with no body field falls back to an empty body', () { const record = Record(id: 'x', fields: {}); final entry = recordToEntry(record); expect(entry.id, 'x'); expect(entry.desc, isEmpty); }); }); group('parseRemoteLog', () { test('parses new-format wire content', () { final entry = _entry(id: 'x'); final pushed = encodeLogForPush({'x': entryToRecord(entry)}); final log = parseRemoteLog(pushed); expect(log['x']!.id, 'x'); }); test('parses old DayLog format for backward compatibility', () { final entry = _entry(id: 'x'); final oldFormat = jsonEncode({ '2026-06-22': [entry.toSyncJson()], }); final log = parseRemoteLog(oldFormat); expect(log['x']!.id, 'x'); }); test('empty object parses as empty log', () { expect(parseRemoteLog('{}'), isEmpty); }); test('non-object top level throws FormatException', () { expect(() => parseRemoteLog('[1, 2, 3]'), throwsFormatException); }); test('old-format day not a list throws FormatException', () { expect( () => parseRemoteLog('{"2026-06-22": "not-a-list"}'), throwsFormatException, ); }); test('invalid JSON throws FormatException', () { expect(() => parseRemoteLog('not json{{{'), throwsFormatException); }); }); group('budget adapters', () { Map budgetRecord({ int b = 2000, String t = '2026-06-22T08:00:00', double? w, }) => {'v': 2, 'b': b, 't': t, if (w != null) 'w': w}; group('budgetHlc', () { test('same record always yields the same Hlc', () { final record = budgetRecord(); expect(budgetHlc(record), budgetHlc({...record})); }); test('malformed t still yields a valid Hlc', () { final record = budgetRecord(t: 'not-a-timestamp'); expect(budgetHlc(record).wallTimeMs, 0); }); test('a later t yields a greater Hlc', () { final earlier = budgetRecord(t: '2020-01-01T00:00:00Z'); final later = budgetRecord(t: '2030-01-01T00:00:00Z'); expect(budgetHlc(later) > budgetHlc(earlier), isTrue); }); }); group('budgetToLog / logToBudget round trip', () { test('null record yields an empty log', () { expect(budgetToLog(null), isEmpty); }); test('round trip preserves the budget and weight', () { final record = budgetRecord(w: 80); final roundTripped = logToBudget(budgetToLog(record)); expect(roundTripped, isNotNull); expect(roundTripped!['b'], 2000); expect(roundTripped['w'], 80); }); test('round-tripped t reflects the winning Hlc', () { final record = budgetRecord(); final roundTripped = logToBudget(budgetToLog(record)); expect(roundTripped, isNotNull); expect(roundTripped!['t'], isNotEmpty); }); test('empty log has no budget', () { expect(logToBudget({}), isNull); }); }); group('parseRemoteBudget', () { test('parses pushed budget wire content', () { final record = budgetRecord(); final pushed = encodeBudgetForPush(budgetToLog(record)); final log = parseRemoteBudget(pushed); expect(log[budgetRecordId]!.id, budgetRecordId); }); test('empty object parses as empty log', () { expect(parseRemoteBudget('{}'), isEmpty); }); test('non-object top level throws FormatException', () { expect(() => parseRemoteBudget('[1, 2, 3]'), throwsFormatException); }); test('invalid JSON throws FormatException', () { expect(() => parseRemoteBudget('not json{{{'), throwsFormatException); }); }); }); }