etm-powersync-app/test/measurement_source_test.dart

/// Le contrat `measurement` de `1.15.2+etm26` — **écrit avant son déploiement**.
///
/// `measuredW` portait trois régimes sous un seul nom et jetait la distinction : une borne
/// rendait une mesure, un routeur de relais une mesure **ou** son palier nominal, un
/// SG-Ready une puissance toujours déclarée. Le régime se publie désormais :
/// `measurement: {source: "meter" | "device" | "none", powerW}`.
///
/// Ces tests figent les trois pièges d'affichage nommés dans le §7 du brief, et la
/// tolérance temporaire vers `measuredW`.
library;

import 'package:etm_powersync_app/l10n/app_localizations.dart';
import 'package:etm_powersync_app/models/load_telemetry.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:etm_powersync_app/providers/load_telemetry_provider.dart';
import 'package:etm_powersync_app/widgets/load_cards.dart';

LoadTelemetryEntry _entree(Map<String, dynamic> extra) =>
    LoadTelemetryEntry.fromJson({
      'loadId': 'x',
      'allocatedW': 3000,
      'available': true,
      'decision': {'code': 'SURPLUS_SETPOINT', 'params': const {}},
      ...extra,
    });

void main() {
  group('le régime est LU, jamais déduit', () {
    test('les trois sources se lisent telles que la box les publie', () {
      expect(
          _entree({
            'measurement': {'source': 'meter', 'powerW': 3980.0}
          }).measurement.source,
          MeasurementSource.meter);
      expect(
          _entree({
            'measurement': {'source': 'device', 'powerW': 12.0}
          }).measurement.source,
          MeasurementSource.device);
      expect(
          _entree({
            'measurement': {'source': 'none'}
          }).measurement.source,
          MeasurementSource.none);
    });

    test('`none` n\'a PAS de puissance — même si la box en met une', () {
      // Le régime est ce qui est publié, pas la valeur : sous `none`, il n'y a rien à
      // afficher, et un nombre qui traînerait ne doit pas ressusciter le bloc.
      final m = _entree({
        'measurement': {'source': 'none', 'powerW': 500.0}
      }).measurement;
      expect(m.powerW, isNull);
      expect(m.mesuree, isFalse);
    });

    test('{device, 0} est une MESURE, pas une absence', () {
      // Une borne branchée qui ne charge pas mesure zéro watt, et c'est une information.
      // Si la source basculait vers `none` à l'extinction, le bloc de mesure
      // apparaîtrait et disparaîtrait au rythme du thermostat.
      final m = _entree({
        'measurement': {'source': 'device', 'powerW': 0.0}
      }).measurement;
      expect(m.mesuree, isTrue);
      expect(m.powerW, 0.0);
    });

    test('une source inconnue n\'est pas devinée', () {
      // Une box plus récente que l'app : on affichera la valeur sans prétendre savoir ce
      // qu'un écart prouverait.
      final m = _entree({
        'measurement': {'source': 'futur', 'powerW': 100.0}
      }).measurement;
      expect(m.source, MeasurementSource.legacy);
      expect(m.mesuree, isTrue);
      expect(m.concordanceProbante, isFalse);
    });
  });

  group('tolérance temporaire vers measuredW — à retirer avec +etm26 sur .75', () {
    test('sans `measurement`, l\'ancienne clé est encore lue', () {
      // Sans cet alias, la mesure disparaîtrait des écrans entre ce livrable et le
      // déploiement du moteur.
      final m = _entree({'measuredW': 1500.0}).measurement;
      expect(m.source, MeasurementSource.legacy);
      expect(m.powerW, 1500.0);
    });

    test('`measurement` GAGNE quand les deux sont là', () {
      // Deux noms pour une chose divergent : le nouveau fait foi, sans exception.
      final m = _entree({
        'measuredW': 1500.0,
        'measurement': {'source': 'meter', 'powerW': 3980.0}
      }).measurement;
      expect(m.source, MeasurementSource.meter);
      expect(m.powerW, 3980.0);
    });

    test('ni l\'un ni l\'autre : pas mesurable', () {
      expect(_entree(const {}).measurement.mesuree, isFalse);
    });
  });

  group('ce qu\'une concordance prouve dépend de la source', () {
    test('seul `meter` rend une concordance probante', () {
      // Plusieurs wallbox renvoient leur consigne en guise de puissance : sous `device`,
      // « commandé 3000, mesuré 3000 » peut n'être qu'un écho.
      for (final (src, attendu) in [
        ('meter', true),
        ('device', false),
        ('none', false),
      ]) {
        expect(
            _entree({
              'measurement': {'source': src, 'powerW': 3000.0}
            }).measurement.concordanceProbante,
            attendu,
            reason: src);
      }
    });
  });

  group('à l\'écran', () {
    Widget carte(Map<String, dynamic> extra) {
      final tel = LoadTelemetryProvider()
        ..adoptForTest({
          'degradedMode': false,
          'loads': [
            {
              'loadId': 'x',
              'allocatedW': 3000,
              'available': true,
              'decision': {'code': 'SURPLUS_SETPOINT', 'params': const {}},
              ...extra,
            }
          ],
        });
      return MaterialApp(
        // `LoadLiveBlock` lit `context.l10n` : sans délégués, il explose avant d'afficher.
        locale: const Locale('fr'),
        localizationsDelegates: L10n.localizationsDelegates,
        supportedLocales: L10n.supportedLocales,
        home: Scaffold(
          body: LoadLiveBlock(
              live: tel.entryFor('x')!, stale: false, telemetry: tel),
        ),
      );
    }

    testWidgets('`none` MASQUE le bloc — pas de vide, pas de zéro', (tester) async {
      await tester.pumpWidget(carte({
        'measurement': {'source': 'none'}
      }));
      expect(find.textContaining('Mesuré'), findsNothing);
      // Et surtout aucun « écart » : « 0 W d'écart » serait la pire des réponses.
      expect(find.textContaining('conforme'), findsNothing);
      expect(find.textContaining('consigne'), findsNothing);
    });

    testWidgets('`device` affiche la mesure ET ce qu\'elle ne prouve pas',
        (tester) async {
      await tester.pumpWidget(carte({
        'measurement': {'source': 'device', 'powerW': 2950.0}
      }));
      expect(find.textContaining('Mesuré 2950 W'), findsOneWidget);
      expect(find.textContaining('une concordance ne prouve rien'), findsOneWidget);
    });

    testWidgets('`meter` dit que la mesure est indépendante', (tester) async {
      await tester.pumpWidget(carte({
        'measurement': {'source': 'meter', 'powerW': 2950.0}
      }));
      expect(find.textContaining('Mesuré 2950 W'), findsOneWidget);
      expect(find.textContaining('mesure indépendante'), findsOneWidget);
    });

    testWidgets('un zéro mesuré s\'affiche — c\'est une information', (tester) async {
      await tester.pumpWidget(carte({
        'measurement': {'source': 'device', 'powerW': 0.0}
      }));
      expect(find.textContaining('Mesuré 0 W'), findsOneWidget);
    });

    testWidgets('sur une box ancienne, la valeur s\'affiche SANS portée',
        (tester) async {
      await tester.pumpWidget(carte({'measuredW': 1500.0}));
      expect(find.textContaining('Mesuré 1500 W'), findsOneWidget);
      expect(find.textContaining('concordance'), findsNothing);
      expect(find.textContaining('indépendante'), findsNothing);
    });
  });
}