[red] Bound and attribute GitHub import failures

Signed-off-by: Viwat Vchirawongkwin <viwat.v@chula.ac.th>

Author: yyods

app/test/unit/connection_manager_test.dart

@@ -231,6 +231,52 @@ void main() {
         reason: 'reattaching the same device id is a new local session',
       );
     });
+
+    test(
+      'local session stamp rotates once when an attached link reconnects',
+      () async {
+        final r = _rig();
+        addTearDown(r.manager.dispose);
+        final Connection facade = r.manager.connection;
+
+        await r.manager.connect(_hitA.id);
+        r.board.emit(ConnState.ready);
+        await pumpEventQueue();
+        final Object establishedStamp = connectionSessionStampOf(facade);
+
+        r.board.emit(ConnState.running);
+        r.board.emit(ConnState.ready);
+        await pumpEventQueue();
+        expect(
+          identical(connectionSessionStampOf(facade), establishedStamp),
+          isTrue,
+          reason: 'ordinary ready/running transitions retain one link session',
+        );
+
+        r.board.emit(ConnState.connecting);
+        await pumpEventQueue();
+        final Object successorStamp = connectionSessionStampOf(facade);
+        expect(identical(successorStamp, establishedStamp), isFalse);
+
+        r.board.emit(ConnState.disconnected);
+        r.board.emit(ConnState.connecting);
+        r.board.emit(ConnState.ready);
+        await pumpEventQueue();
+        expect(
+          identical(connectionSessionStampOf(facade), successorStamp),
+          isTrue,
+          reason: 'one departure rotates once for the complete reconnect',
+        );
+
+        r.board.emit(ConnState.disconnected);
+        await pumpEventQueue();
+        expect(
+          identical(connectionSessionStampOf(facade), successorStamp),
+          isFalse,
+          reason: 'a later established-session departure rotates again',
+        );
+      },
+    );
   });
 
   group('A-22 ConnectionManager — not-connected + failure', () {

app/test/unit/github_repository_client_test.dart

@@ -37,7 +37,7 @@ GithubEntry _helloEntry() => const GithubEntry(
   remotePath: 'examples/hello.py',
   kind: GithubEntryKind.regularFile,
   objectSha: _helloBlobSha,
-  declaredSize: 18,
+  declaredSize: 15,
 );
 
 void _expectGitHubRequest(http.Request request) {
@@ -550,6 +550,55 @@ void main() {
   });
 
   group('GithubRepositoryClient failures', () {
+    test('enforces one absolute deadline against a trickling body', () async {
+      final StreamController<List<int>> body = StreamController<List<int>>();
+      final Completer<void> abortObserved = Completer<void>();
+      Timer? trickle;
+      final MockClient httpClient = MockClient.streaming((
+        http.BaseRequest request,
+        http.ByteStream requestBody,
+      ) async {
+        expect(request, isA<http.AbortableRequest>());
+        final http.AbortableRequest abortable =
+            request as http.AbortableRequest;
+        trickle = Timer.periodic(const Duration(milliseconds: 10), (_) {
+          if (!body.isClosed) body.add(const <int>[0x20]);
+        });
+        unawaited(
+          abortable.abortTrigger!.then((_) async {
+            if (!abortObserved.isCompleted) abortObserved.complete();
+            trickle?.cancel();
+            if (!body.isClosed) await body.close();
+          }),
+        );
+        return http.StreamedResponse(body.stream, HttpStatus.ok);
+      });
+      final GithubRepositoryClient api = GithubRepositoryClient(
+        httpClient: httpClient,
+        timeout: const Duration(milliseconds: 80),
+      );
+      final Stopwatch elapsed = Stopwatch()..start();
+
+      try {
+        await expectLater(
+          api
+              .resolve(_locator(), ref: 'main')
+              .timeout(const Duration(seconds: 1)),
+          throwsA(_githubFailure(GithubFailureKind.offline)),
+        );
+        expect(elapsed.elapsed, lessThan(const Duration(milliseconds: 500)));
+        await expectLater(
+          abortObserved.future.timeout(const Duration(milliseconds: 200)),
+          completes,
+        );
+      } finally {
+        elapsed.stop();
+        trickle?.cancel();
+        if (!body.isClosed) await body.close();
+        httpClient.close();
+      }
+    });
+
     test(
       'cancels response bodies rejected by status or declared length',
       () async {

app/test/widget/github_import_view_test.dart

@@ -9,10 +9,10 @@
 
 import 'dart:async';
 import 'dart:convert';
-import 'dart:typed_data';
 
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 
 import 'package:pyble/files/files.dart';
@@ -245,6 +245,17 @@ Future<void> _browse(
   await tester.pumpAndSettle();
 }
 
+Future<void> _activateButtonWithEnter(WidgetTester tester, Key key) async {
+  final Finder button = find.byKey(key);
+  final Finder label = find.descendant(of: button, matching: find.byType(Text));
+  final FocusNode focusNode = Focus.of(tester.element(label));
+  focusNode.requestFocus();
+  await tester.pump();
+  expect(focusNode.hasFocus, isTrue);
+  await tester.sendKeyEvent(LogicalKeyboardKey.enter);
+  await tester.pumpAndSettle();
+}
+
 void main() {
   group('A-33 GitHub import — adaptive connected Files workflow', () {
     testWidgets(
@@ -331,6 +342,34 @@ void main() {
       expect(find.byKey(kGithubRefFieldKey), findsOneWidget);
     });
 
+    testWidgets('hardware Enter activates Browse and Review', (
+      WidgetTester tester,
+    ) async {
+      final RecordingConnection connection = RecordingConnection(
+        initial: ConnState.ready,
+      );
+      final _FakeGithubApi api = _FakeGithubApi(
+        entries: const <GithubEntry>[_helloEntry],
+      );
+      addTearDown(connection.dispose);
+
+      await _openImport(tester, connection, api);
+      await tester.enterText(
+        find.byKey(kGithubRepositoryFieldKey),
+        'https://github.com/PyBLE-dev/examples',
+      );
+      await _activateButtonWithEnter(tester, kGithubBrowseButtonKey);
+
+      expect(api.resolveCalls, hasLength(1));
+      expect(api.listedRemotePaths, <String>['']);
+      await tester.tap(find.byKey(_selectionKey('hello.py')));
+      await tester.pump();
+      await _activateButtonWithEnter(tester, kGithubReviewButtonKey);
+
+      expect(find.text(l10nOf(tester).githubImportReviewTitle), findsOneWidget);
+      expect(connection.putFileCalls, isEmpty);
+    });
+
     testWidgets(
       'an existing target needs a separate localized confirmation; Cancel writes nothing',
       (WidgetTester tester) async {
@@ -450,6 +489,20 @@ void main() {
             hasFocusAction: true,
           ),
         );
+        Finder failureLiveRegions() => find.descendant(
+          of: failure,
+          matching: find.byWidgetPredicate(
+            (Widget widget) =>
+                widget is Semantics && widget.properties.liveRegion == true,
+          ),
+        );
+        expect(failureLiveRegions(), findsOneWidget);
+        final int failureNodeId = tester.getSemantics(failureLiveRegions()).id;
+        tester.platformDispatcher.textScaleFactorTestValue = 1.1;
+        addTearDown(tester.platformDispatcher.clearTextScaleFactorTestValue);
+        await tester.pump();
+        expect(failureLiveRegions(), findsOneWidget);
+        expect(tester.getSemantics(failureLiveRegions()).id, failureNodeId);
         expect(find.text(l10nOf(tester).githubImportRetry), findsNothing);
         expect(
           tester
@@ -571,10 +624,23 @@ void main() {
           const ValueKey<String>('githubImportResult'),
         );
         expect(result, findsOneWidget);
+        Finder resultLiveRegions() => find.byWidgetPredicate(
+          (Widget widget) =>
+              widget is Semantics &&
+              widget.key == const ValueKey<String>('githubImportResult') &&
+              widget.properties.liveRegion == true,
+        );
+        expect(resultLiveRegions(), findsOneWidget);
         expect(
           tester.getSemantics(result),
           matchesSemantics(isLiveRegion: true),
         );
+        final int resultNodeId = tester.getSemantics(resultLiveRegions()).id;
+        tester.platformDispatcher.textScaleFactorTestValue = 1.1;
+        addTearDown(tester.platformDispatcher.clearTextScaleFactorTestValue);
+        await tester.pumpAndSettle();
+        expect(resultLiveRegions(), findsOneWidget);
+        expect(tester.getSemantics(resultLiveRegions()).id, resultNodeId);
       },
     );
 
@@ -712,6 +778,42 @@ void main() {
       );
     });
 
+    testWidgets('a size failure identifies its safe repository path', (
+      WidgetTester tester,
+    ) async {
+      const GithubEntry oversized = GithubEntry(
+        name: 'oversized.py',
+        remotePath: 'examples/oversized.py',
+        kind: GithubEntryKind.regularFile,
+        objectSha: _helloBlobSha,
+        declaredSize: 21,
+      );
+      final RecordingConnection connection = RecordingConnection(
+        initial: ConnState.ready,
+      );
+      final _FakeGithubApi api = _FakeGithubApi(
+        entries: const <GithubEntry>[oversized],
+        fetchFailuresRemaining: 1,
+        fetchFailure: const GithubFailure(
+          GithubFailureKind.fileTooLarge,
+          path: 'examples/oversized.py',
+        ),
+      );
+      addTearDown(connection.dispose);
+
+      await _openImport(tester, connection, api);
+      await _browse(tester);
+      await tester.tap(find.byKey(_selectionKey('examples/oversized.py')));
+      await tester.pump();
+      await tester.tap(find.byKey(kGithubReviewButtonKey));
+      await tester.pumpAndSettle();
+      await tester.tap(find.byKey(kGithubCommitButtonKey));
+      await tester.pumpAndSettle();
+
+      expect(connection.putFileCalls, isEmpty);
+      expect(find.textContaining('examples/oversized.py'), findsOneWidget);
+    });
+
     testWidgets('a rate-limited blob retry waits without writing', (
       WidgetTester tester,
     ) async {