TPSchedule/mobile/test/school/school_session_flow_test.dart

import 'dart:async';
import 'dart:convert';

import 'package:flutter_test/flutter_test.dart';
import 'package:webview_flutter_platform_interface/webview_flutter_platform_interface.dart';
import 'package:hepan_everyday/features/school/school_session.dart';
import 'package:hepan_everyday/features/school/school_exam_adapter.dart';

import '../support/fake_school_web.dart';
import 'exam_adapter_test.dart' show examHtml;

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();
  late FakeSchoolPlatform platform;
  late SchoolSession session;
  setUp(() {
    platform = FakeSchoolPlatform();
    WebViewPlatform.instance = platform;
    session = SchoolSession();
  });
  tearDown(() => session.dispose());
  void navigate(String url) {
    platform.web.url = url;
    platform.delegate.started(url);
    platform.delegate.finished(url);
  }

  test('actual session follows service login then reads exam HTML', () async {
    await session.openExams();
    expect(platform.web.loads.single, SchoolSession.authUrl.toString());
    navigate('https://idas.uestc.edu.cn/authserver/login?service=graduate');
    await flushSchoolEvents();
    expect(session.connectionState, SchoolConnectionState.authenticating);
    expect(session.finding, isFalse);
    platform.web.javascript = (script) async =>
        script.contains('outerHTML') ? jsonEncode(examHtml()) : true;
    navigate('http://yjsjy.uestc.edu.cn/pyxx/home/index');
    await flushSchoolEvents();
    expect(platform.web.loads.last, SchoolSession.examUrl.toString());
    expect(session.finding, isTrue);
    navigate(SchoolSession.examUrl.toString());
    await flushSchoolEvents();
    expect(session.pendingExams!.records.single.name, '矩阵理论');
    expect(session.connectionState, SchoolConnectionState.connected);
  });
  test(
    'obsolete main-frame error cannot interrupt a newer exam read',
    () async {
      await session.openExams();
      platform.web.javascript = (_) async => jsonEncode(examHtml());
      navigate(SchoolSession.examUrl.toString());
      await flushSchoolEvents();
      platform.delegate.resourceError(
        const WebResourceError(
          errorCode: -2,
          description: 'old request',
          isForMainFrame: true,
          url: 'https://yjsjy.uestc.edu.cn/pyxx/pygl/xskbcx/index/1',
        ),
      );
      await flushSchoolEvents();
      expect(session.finding, isTrue);
      expect(session.message, '读取成功，正在保存…');
    },
  );
  test(
    'open waits for logout so old clearing cannot blank the new login',
    () async {
      await session.open();
      platform.cookies.clearing = Completer<bool>();
      final closing = session.logout();
      await flushSchoolEvents();
      final reopening = session.openExams();
      await flushSchoolEvents();
      platform.cookies.clearing!.complete(true);
      await closing;
      await reopening;
      expect(session.hasOpened, isTrue);
      expect(platform.web.loads.last, SchoolSession.authUrl.toString());
      expect(session.requestingExams, isTrue);
    },
  );
  test(
    'acknowledging an old saved draft preserves a newer pending import',
    () async {
      await session.openExams();
      final old = SchoolExamAdapter.extract(examHtml());
      session.pendingExams = old;
      final generation = session.pageGeneration;
      await session.openExams();
      final newer = SchoolExamAdapter.extract(examHtml(room: '品学楼A101'));
      session.pendingExams = newer;
      expect(
        session.saved(success: true, generation: generation, exams: old),
        isFalse,
      );
      expect(session.pendingExams, same(newer));
      expect(
        session.saved(
          success: true,
          generation: session.pageGeneration,
          exams: newer,
        ),
        isTrue,
      );
      expect(session.pendingExams, isNull);
    },
  );
  test(
    'native logout failure is reported and subsequent login can recover',
    () async {
      await session.open();
      session.connectionState = SchoolConnectionState.connected;
      platform.cookies.clearing = Completer<bool>();
      final closing = session.logout();
      final result = closing.then((_) => true, onError: (_) => false);
      platform.cookies.clearing!.completeError(
        StateError('cookie clearing failed'),
      );
      expect(await result, isTrue);
      expect(session.connectionState, isNot(SchoolConnectionState.connected));
      expect(session.message, contains('退出未完成'));
      await session.openExams();
      expect(platform.web.loads.last, SchoolSession.authUrl.toString());
    },
  );
  test('university HTTP identity redirect upgrades to HTTPS with service preserved', () async {
    await session.open();
    const redirect =
        'http://idas.uestc.edu.cn/authserver/login?service=http%3A%2F%2Fyjsjy.uestc.edu.cn%2Fpyxx%2Fjzsso%2Flogin';
    final decision = await platform.delegate.navigation(
      const NavigationRequest(url: redirect, isMainFrame: true),
    );
    expect(decision, NavigationDecision.prevent);
    final opened = Uri.parse(platform.web.loads.last);
    expect(opened.host, 'idas.uestc.edu.cn');
    expect(opened.scheme, 'https');
    expect(opened.query, Uri.parse(redirect).query);
  });
}