test: add coverage for CompactAutoResetController and auto-compact extension

Author: SERDUN

test/features/call/utils/compact_auto_reset_controller_test.dart

@@ -0,0 +1,217 @@
+import 'package:fake_async/fake_async.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import 'package:webtrit_phone/features/call/call.dart';
+
+import '../../../mocks/mocks.dart';
+
+void main() {
+  group('CompactAutoResetController', () {
+    late CompactAutoResetController controller;
+    const int autoResetSeconds = 5;
+
+    setUp(() {
+      controller = CompactAutoResetController(autoResetSeconds: autoResetSeconds);
+    });
+
+    tearDown(() {
+      controller.dispose();
+    });
+
+    test('Initial state is inactive and expanded (not compact)', () {
+      expect(controller.active, isFalse);
+      expect(controller.compact, isFalse);
+      expect(controller.isRunning, isFalse);
+    });
+
+    test('Constructor throws assertion error if autoResetSeconds <= 0', () {
+      expect(() => CompactAutoResetController(autoResetSeconds: 0), throwsA(isA<AssertionError>()));
+    });
+
+    test('activate() starts the timer and switches to compact after timeout', () {
+      fakeAsync((async) {
+        controller.activate();
+
+        // Immediately active but still expanded
+        expect(controller.active, isTrue);
+        expect(controller.compact, isFalse);
+        expect(controller.isRunning, isTrue);
+
+        // Advance time partially (2s)
+        async.elapse(const Duration(seconds: 2));
+        expect(controller.compact, isFalse);
+
+        // Advance time past limit (Total 5s)
+        async.elapse(const Duration(seconds: 3));
+        expect(controller.compact, isTrue);
+
+        // Timer should stop after compacting
+        expect(controller.isRunning, isFalse);
+      });
+    });
+
+    test('deactivate() stops the timer and resets state', () {
+      fakeAsync((async) {
+        controller.activate();
+        async.elapse(const Duration(seconds: 2));
+
+        controller.deactivate();
+
+        expect(controller.active, isFalse);
+        expect(controller.compact, isFalse);
+        expect(controller.isRunning, isFalse);
+
+        // Advance time past original timeout - nothing should happen
+        async.elapse(const Duration(seconds: 10));
+        expect(controller.compact, isFalse);
+      });
+    });
+
+    test('poke() resets the countdown', () {
+      fakeAsync((async) {
+        controller.activate();
+
+        // 4 seconds passed (1s left)
+        async.elapse(const Duration(seconds: 4));
+        expect(controller.compact, isFalse);
+
+        // User interaction!
+        controller.poke();
+
+        // 2 more seconds passed (Total 6s, but only 2s since poke)
+        async.elapse(const Duration(seconds: 2));
+        expect(controller.compact, isFalse);
+
+        // 3 more seconds passed (Total 5s since poke)
+        async.elapse(const Duration(seconds: 3));
+        expect(controller.compact, isTrue);
+      });
+    });
+
+    test('poke() is ignored if controller is inactive', () {
+      fakeAsync((async) {
+        controller.poke(); // Should do nothing
+        expect(controller.isRunning, isFalse);
+      });
+    });
+
+    test('poke() is ignored if already compact', () {
+      fakeAsync((async) {
+        controller.activate();
+        controller.setCompact(true); // Force compact
+
+        controller.poke(); // Should NOT restart timer
+
+        async.elapse(const Duration(seconds: 1));
+        expect(controller.compact, isTrue); // Should remain compact
+      });
+    });
+
+    test('toggle() manually switches state and manages timer', () {
+      fakeAsync((async) {
+        controller.activate();
+
+        // Manually compact
+        controller.toggle();
+        expect(controller.compact, isTrue);
+        expect(controller.isRunning, isFalse); // Timer shouldn't run when compact
+
+        // Manually expand
+        controller.toggle();
+        expect(controller.compact, isFalse);
+        expect(controller.isRunning, isTrue); // Timer should restart
+
+        // Should compact again after timeout
+        async.elapse(const Duration(seconds: 5));
+        expect(controller.compact, isTrue);
+      });
+    });
+  });
+
+  group('ActiveCallListAutoCompact Extension', () {
+    test('Returns false for empty list', () {
+      final List<ActiveCall> calls = [];
+      expect(calls.shouldAutoCompact, isFalse);
+    });
+
+    test('Returns TRUE only for CallProcessingStatus.connected', () {
+      // Loop through ALL statuses defined in the enum
+      for (final status in CallProcessingStatus.values) {
+        final calls = [MockActiveCall(processingStatus: status, cameraEnabled: true, remoteVideo: true)];
+
+        if (status == CallProcessingStatus.connected) {
+          expect(calls.shouldAutoCompact, isTrue, reason: 'Status $status should allow compact mode');
+        } else {
+          expect(calls.shouldAutoCompact, isFalse, reason: 'Status $status should NOT allow compact mode');
+        }
+      }
+    });
+
+    test('Returns false if any call was hung up', () {
+      final calls = [
+        MockActiveCall(
+          processingStatus: CallProcessingStatus.connected,
+          wasHungUp: true,
+          cameraEnabled: true,
+          remoteVideo: true,
+        ),
+      ];
+      expect(calls.shouldAutoCompact, isFalse);
+    });
+
+    test('Returns true ONLY if cameraEnabled AND remoteVideo (Both active)', () {
+      final calls = [
+        MockActiveCall(processingStatus: CallProcessingStatus.connected, cameraEnabled: true, remoteVideo: true),
+      ];
+      expect(calls.shouldAutoCompact, isTrue);
+    });
+
+    test('Returns false if local camera is OFF (The "Black Void" prevention)', () {
+      // UX Logic: If I turn off my camera, I must see the UI,
+      // even if the remote side sends video (or black frames).
+      final calls = [
+        MockActiveCall(
+          processingStatus: CallProcessingStatus.connected,
+          cameraEnabled: false, // Local OFF
+          remoteVideo: true, // Remote ON
+        ),
+      ];
+      expect(
+        calls.shouldAutoCompact,
+        isFalse,
+        reason: 'UI must remain visible when local camera is off to prevent black screen',
+      );
+    });
+
+    test('Returns false if remote video is OFF', () {
+      final calls = [
+        MockActiveCall(processingStatus: CallProcessingStatus.connected, cameraEnabled: true, remoteVideo: false),
+      ];
+      expect(calls.shouldAutoCompact, isFalse);
+    });
+
+    test('Multi-call: Returns true if all connected and at least one has full video', () {
+      final calls = [
+        // Call 1: Audio only (Connected)
+        MockActiveCall(processingStatus: CallProcessingStatus.connected, cameraEnabled: false, remoteVideo: false),
+        // Call 2: Video (Connected & Full Video)
+        MockActiveCall(processingStatus: CallProcessingStatus.connected, cameraEnabled: true, remoteVideo: true),
+      ];
+      expect(calls.shouldAutoCompact, isTrue);
+    });
+
+    test('Multi-call: Returns false if ANY call is not connected', () {
+      final calls = [
+        // Call 1: Still ringing
+        MockActiveCall(
+          processingStatus: CallProcessingStatus.outgoingRinging,
+          cameraEnabled: false,
+          remoteVideo: false,
+        ),
+        // Call 2: Connected Video
+        MockActiveCall(processingStatus: CallProcessingStatus.connected, cameraEnabled: true, remoteVideo: true),
+      ];
+      expect(calls.shouldAutoCompact, isFalse);
+    });
+  });
+}

test/mocks/mock_active_call.dart

@@ -0,0 +1,24 @@
+import 'package:mocktail/mocktail.dart';
+
+import 'package:webtrit_phone/features/call/call.dart';
+
+class MockActiveCall extends Fake implements ActiveCall {
+  MockActiveCall({
+    this.processingStatus = CallProcessingStatus.connected,
+    this.wasHungUp = false,
+    this.cameraEnabled = false,
+    this.remoteVideo = false,
+  });
+
+  @override
+  final CallProcessingStatus processingStatus;
+
+  @override
+  final bool wasHungUp;
+
+  @override
+  final bool cameraEnabled;
+
+  @override
+  final bool remoteVideo;
+}

test/mocks/mocks.dart

@@ -1,4 +1,5 @@
 export 'fake_connectivity_service.dart';
+export 'mock_active_call.dart';
 export 'mock_app_preferences.dart';
 export 'mock_secure_storage.dart';
 export 'mock_system_info.dart';