ReelShort/test/mine/mine_logic_test.dart

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:nontonki/core/config/locale_controller.dart';
import 'package:nontonki/core/data/models/drama.dart';
import 'package:nontonki/l10n/app_localizations.dart';
import 'package:nontonki/pages/mine/mine_logic.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences_platform_interface/in_memory_shared_preferences_async.dart';
import 'package:shared_preferences_platform_interface/shared_preferences_async_platform_interface.dart';

import '../support/fake_watch_history.dart';

Drama _drama(String id, {List<int> numbers = const [1, 2, 3]}) => Drama(
  id: id,
  title: id,
  synopsis: 'synopsis',
  posterUrl: '/files/poster.png',
  episodes: [
    for (final number in numbers)
      Episode(
        id: '$id-$number',
        number: number,
        title: 'Episode $number',
        videoUrl: 'https://example.test/clip.mp4',
        isFree: true,
      ),
  ],
);

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();

  test('the constructor keeps the requested section and reads episode one', () async {
    final history = FakeWatchHistory()..saved = const Duration(seconds: 7);
    final logic = MineLogic(
      history: history,
      drama: _drama('signal'),
      initialSection: 1,
    );

    expect(logic.section, 1);
    expect(logic.filter, 0);
    expect(await logic.position, const Duration(seconds: 7));
    expect(history.reads, ['demo-local-v1|signal|signal-1']);
    logic.dispose();
  });

  test('a list card without episodes resumes from the last watch', () async {
    final history = FakeWatchHistory()
      ..saved = const Duration(seconds: 7)
      ..lastEpisode = 'signal-3';
    final logic = MineLogic(
      history: history,
      drama: _drama('signal', numbers: const []),
      initialSection: 1,
    );

    expect(await logic.position, const Duration(seconds: 7));
    expect(history.reads, ['demo-local-v1|signal|signal-3']);
    logic.dispose();
  });

  test('section and filter selections notify', () {
    final logic = MineLogic(
      history: FakeWatchHistory(),
      drama: _drama('s'),
      initialSection: 0,
    );
    var notifications = 0;
    logic.addListener(() => notifications++);

    logic.selectSection(1);
    expect(logic.section, 1);
    expect(notifications, 1);

    logic.selectFilter(2);
    expect(logic.filter, 2);
    expect(notifications, 2);
    logic.dispose();
  });

  test('syncPage only adopts a drama while the page is active', () {
    final history = FakeWatchHistory();
    final logic = MineLogic(
      history: history,
      drama: _drama('signal'),
      initialSection: 0,
    );

    void sync(
      Drama next, {
      required bool active,
      required bool wasActive,
      required bool dramaChanged,
      int sectionRequest = 0,
      int previousSectionRequest = 0,
      int initialSection = 0,
    }) => logic.syncPage(
      active: active,
      wasActive: wasActive,
      nextDrama: next,
      dramaChanged: dramaChanged,
      sectionRequest: sectionRequest,
      previousSectionRequest: previousSectionRequest,
      initialSection: initialSection,
    );

    sync(_drama('city'), active: false, wasActive: true, dramaChanged: true);
    expect(logic.drama.id, 'signal');

    sync(_drama('city'), active: true, wasActive: false, dramaChanged: false);
    expect(logic.drama.id, 'city');

    history.reads.clear();
    sync(_drama('vengeance'), active: true, wasActive: true, dramaChanged: true);
    expect(logic.drama.id, 'vengeance');
    expect(history.reads, ['demo-local-v1|vengeance|vengeance-1']);

    history.reads.clear();
    sync(_drama('other'), active: true, wasActive: true, dramaChanged: false);
    expect(logic.drama.id, 'vengeance');
    expect(history.reads, isEmpty);
    logic.dispose();
  });

  test('a section request resets the section even while the page is inactive', () {
    final logic = MineLogic(
      history: FakeWatchHistory(),
      drama: _drama('s'),
      initialSection: 0,
    );

    logic.syncPage(
      active: false,
      wasActive: false,
      nextDrama: logic.drama,
      dramaChanged: false,
      sectionRequest: 1,
      previousSectionRequest: 0,
      initialSection: 1,
    );

    expect(logic.section, 1);
    logic.dispose();
  });

  testWidgets('act returns the choice for a page and forwards it when embedded', (
    tester,
  ) async {
    final logic = MineLogic(
      history: FakeWatchHistory(),
      drama: _drama('s'),
      initialSection: 0,
    );
    final forwarded = <MyPageAction>[];
    final popped = Completer<MyPageAction?>();
    late BuildContext pageContext;

    await tester.pumpWidget(
      MaterialApp(
        home: Builder(
          builder: (context) => TextButton(
            onPressed: () => Navigator.of(context)
                .push<MyPageAction>(
                  MaterialPageRoute<MyPageAction>(
                    builder: (inner) {
                      pageContext = inner;
                      return const SizedBox.shrink();
                    },
                  ),
                )
                .then(popped.complete),
            child: const Text('open'),
          ),
        ),
      ),
    );

    await tester.tap(find.text('open'));
    await tester.pumpAndSettle();

    logic.act(
      pageContext,
      MyPageAction.discover,
      embedded: true,
      onAction: forwarded.add,
    );
    expect(forwarded, [MyPageAction.discover]);
    expect(Navigator.of(pageContext).canPop(), isTrue);

    logic.act(pageContext, MyPageAction.resume, embedded: false);
    await tester.pumpAndSettle();

    await expectLater(popped.future, completion(MyPageAction.resume));
    logic.dispose();
  });

  testWidgets('the language sheet switches the app locale', (tester) async {
    SharedPreferencesAsyncPlatform.instance =
        InMemorySharedPreferencesAsync.empty();
    final locale = LocaleController();
    final logic = MineLogic(
      history: FakeWatchHistory(),
      drama: _drama('s'),
      initialSection: 0,
    );
    late BuildContext context;

    await tester.pumpWidget(
      ChangeNotifierProvider<LocaleController>.value(
        value: locale,
        child: MaterialApp(
          locale: const Locale('en'),
          localizationsDelegates: AppLocalizations.localizationsDelegates,
          supportedLocales: AppLocalizations.supportedLocales,
          home: Builder(
            builder: (inner) {
              context = inner;
              return const Scaffold(body: SizedBox.shrink());
            },
          ),
        ),
      ),
    );

    unawaited(logic.showLanguage(context));
    await tester.pumpAndSettle();

    final l10n = AppLocalizations.of(context)!;
    expect(find.text(l10n.english), findsOneWidget);
    expect(find.text(l10n.simplifiedChinese), findsOneWidget);

    await tester.tap(find.text(l10n.simplifiedChinese));
    await tester.pumpAndSettle();

    expect(locale.locale, const Locale('zh'));
    logic.dispose();
  });

  test('notify after dispose is a no-op', () {
    final logic = MineLogic(
      history: FakeWatchHistory(),
      drama: _drama('s'),
      initialSection: 0,
    );
    var notifications = 0;
    logic.addListener(() => notifications++);

    logic.dispose();
    logic.notify();

    expect(notifications, 0);
  });
}