tests: add all tests for terminal related features(coverage: 100)

Author: Udhay-Adithya

test/models/terminal_models_test.dart

@@ -0,0 +1,133 @@
+import 'package:test/test.dart';
+import 'package:apidash/consts.dart';
+import 'package:apidash/models/terminal/models.dart';
+import 'package:apidash_core/apidash_core.dart';
+
+void main() {
+  group('TerminalEntry model', () {
+    test('copyWith preserves immutability and updates fields', () {
+      final entry = TerminalEntry(
+        id: 'e1',
+        source: TerminalSource.system,
+        level: TerminalLevel.info,
+        system: SystemLogData(category: 'ui', message: 'hello'),
+      );
+
+      final ts = DateTime.fromMillisecondsSinceEpoch(1000);
+      final updated = entry.copyWith(
+        ts: ts,
+        level: TerminalLevel.warn,
+        system: SystemLogData(category: 'io', message: 'updated'),
+      );
+
+      expect(updated.id, 'e1');
+      expect(updated.ts, ts);
+      expect(updated.level, TerminalLevel.warn);
+      expect(updated.system?.category, 'io');
+      expect(entry.system?.category, 'ui');
+    });
+
+    test('supports js and network data variants', () {
+      final jsEntry = TerminalEntry(
+        id: 'j1',
+        source: TerminalSource.js,
+        level: TerminalLevel.error,
+        js: JsLogData(level: 'error', args: ['a', 'b'], stack: 'trace'),
+      );
+      expect(jsEntry.js, isNotNull);
+      expect(jsEntry.system, isNull);
+
+      final netEntry = TerminalEntry(
+        id: 'n1',
+        source: TerminalSource.network,
+        level: TerminalLevel.info,
+        network: NetworkLogData(
+          phase: NetworkPhase.started,
+          apiType: APIType.rest,
+          method: HTTPVerb.get,
+          url: 'https://api.apidash.dev',
+        ),
+      );
+      expect(netEntry.network, isNotNull);
+      expect(netEntry.js, isNull);
+    });
+  });
+
+  group('NetworkLogData model', () {
+    test('copyWith updates fields and keeps others', () {
+      final n = NetworkLogData(
+        phase: NetworkPhase.started,
+        apiType: APIType.rest,
+        method: HTTPVerb.post,
+        url: 'https://api.apidash.dev',
+        requestHeaders: const {'A': '1'},
+        requestBodyPreview: '{x}',
+      );
+
+      final completedAt = DateTime.fromMillisecondsSinceEpoch(5000);
+      final c = n.copyWith(
+        phase: NetworkPhase.completed,
+        responseStatus: 200,
+        responseHeaders: const {'B': '2'},
+        responseBodyPreview: 'ok',
+        duration: const Duration(milliseconds: 123),
+        isStreaming: true,
+        completedAt: completedAt,
+      );
+
+      expect(c.phase, NetworkPhase.completed);
+      expect(c.responseStatus, 200);
+      expect(c.responseHeaders, {'B': '2'});
+      expect(c.requestHeaders, {'A': '1'});
+      expect(c.requestBodyPreview, '{x}');
+      expect(c.responseBodyPreview, 'ok');
+      expect(c.duration?.inMilliseconds, 123);
+      expect(c.isStreaming, true);
+      expect(c.completedAt, completedAt);
+    });
+
+    test('copyWith preserves phase when not provided', () {
+      final n = NetworkLogData(
+        phase: NetworkPhase.started,
+        apiType: APIType.rest,
+        method: HTTPVerb.get,
+        url: 'https://api.apidash.dev',
+      );
+
+      // Do not pass phase; update another field
+      final c = n.copyWith(responseStatus: 201);
+
+      expect(c.phase, NetworkPhase.started);
+      expect(c.responseStatus, 201);
+      // Verify some other fields are preserved
+      expect(c.apiType, APIType.rest);
+      expect(c.method, HTTPVerb.get);
+      expect(c.url, 'https://api.apidash.dev');
+    });
+
+    test('BodyChunk stores timestamp, text and size', () {
+      final t = DateTime.fromMillisecondsSinceEpoch(42);
+      final b = BodyChunk(ts: t, text: 'hello', sizeBytes: 5);
+      expect(b.ts, t);
+      expect(b.text, 'hello');
+      expect(b.sizeBytes, 5);
+    });
+  });
+
+  group('JsLogData & SystemLogData', () {
+    test('JsLogData holds args, level and optional context', () {
+      final j = JsLogData(level: 'warn', args: ['x', 'y'], context: 'pre');
+      expect(j.level, 'warn');
+      expect(j.args, ['x', 'y']);
+      expect(j.context, 'pre');
+      expect(j.stack, isNull);
+    });
+
+    test('SystemLogData stores category, message and stack', () {
+      final s = SystemLogData(category: 'provider', message: 'm', stack: 'st');
+      expect(s.category, 'provider');
+      expect(s.message, 'm');
+      expect(s.stack, 'st');
+    });
+  });
+}

test/providers/terminal_providers_test.dart

@@ -0,0 +1,231 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:apidash/providers/terminal_providers.dart';
+import 'package:apidash/models/terminal/models.dart';
+import 'package:apidash/consts.dart';
+import 'package:apidash_core/apidash_core.dart';
+
+void main() {
+  group('TerminalController', () {
+    late ProviderContainer container;
+    late TerminalController controller;
+
+    setUp(() {
+      container = ProviderContainer();
+      controller = container.read(terminalStateProvider.notifier);
+    });
+
+    tearDown(() {
+      container.dispose();
+    });
+
+    test('initial state is empty', () {
+      final state = container.read(terminalStateProvider);
+      expect(state.entries, isEmpty);
+      expect(state.index, isEmpty);
+    });
+
+    test('log system entries and clear', () {
+      controller.logSystem(category: 'ui', message: 'opened');
+      controller.logSystem(
+          category: 'provider', message: 'updated', level: TerminalLevel.warn);
+      final state = container.read(terminalStateProvider);
+      expect(state.entries.length, 2);
+      expect(state.entries.first.system?.category, anyOf('ui', 'provider'));
+
+      // serialization has timestamps, uppercase level and title-cased source
+      final text = controller.serializeAll();
+      expect(text, contains('INFO'));
+      expect(text, contains('System'));
+      expect(text.toLowerCase(), contains('opened'));
+
+      controller.clear();
+      expect(container.read(terminalStateProvider).entries, isEmpty);
+    });
+
+    test('JS logs map levels and include args', () {
+      controller.logJs(level: 'log', args: ['hello']);
+      controller.logJs(level: 'warn', args: ['warn']);
+      controller.logJs(level: 'error', args: ['err'], context: 'preRequest');
+      final state = container.read(terminalStateProvider);
+      expect(state.entries.length, 3);
+      final levels = state.entries.map((e) => e.level).toList();
+      expect(levels.contains(TerminalLevel.info), isTrue);
+      expect(levels.contains(TerminalLevel.warn), isTrue);
+      expect(levels.contains(TerminalLevel.error), isTrue);
+
+      final title0 = controller.titleFor(state.entries.first);
+      final sub0 = controller.subtitleFor(state.entries.first);
+      expect(title0.toLowerCase(), contains('js'));
+      expect(sub0, isNotNull);
+    });
+
+    test('network lifecycle: start -> chunk -> complete', () async {
+      final id = controller.startNetwork(
+        apiType: APIType.rest,
+        method: HTTPVerb.get,
+        url: 'https://example.com',
+        requestHeaders: const {'A': '1'},
+        requestBodyPreview: 'req',
+        isStreaming: true,
+      );
+      expect(container.read(terminalStateProvider).entries, isNotEmpty);
+
+      controller.addNetworkChunk(
+        id,
+        BodyChunk(
+          ts: DateTime.now(),
+          text: 'chunk1',
+          sizeBytes: 6,
+        ),
+      );
+
+      controller.completeNetwork(
+        id,
+        statusCode: 200,
+        responseHeaders: const {'B': '2'},
+        responseBodyPreview: 'ok',
+        duration: const Duration(milliseconds: 88),
+      );
+
+      final e = container.read(terminalStateProvider).entries.first;
+      expect(e.network?.phase, NetworkPhase.completed);
+      expect(e.level, TerminalLevel.info);
+      expect(e.network?.responseStatus, 200);
+      expect(e.network?.duration?.inMilliseconds, 88);
+
+      // Helpers
+      final title = controller.titleFor(e);
+      final sub = controller.subtitleFor(e);
+      expect(title, contains('GET'));
+      expect(title, contains('https://example.com'));
+      expect(sub, 'ok');
+
+      // Serialization should include status code
+      final ser = controller.serializeAll();
+      expect(ser, contains('200'));
+    });
+
+    test('network failure switches level to error', () {
+      final id = controller.startNetwork(
+        apiType: APIType.rest,
+        method: HTTPVerb.post,
+        url: 'https://api',
+      );
+      controller.failNetwork(id, 'timeout');
+      final e = container.read(terminalStateProvider).entries.first;
+      expect(e.level, TerminalLevel.error);
+      expect(e.network?.phase, NetworkPhase.failed);
+      expect(controller.subtitleFor(e), 'timeout');
+    });
+
+    test('completeNetwork maps 4xx/5xx to error level', () {
+      final id = controller.startNetwork(
+        apiType: APIType.rest,
+        method: HTTPVerb.get,
+        url: 'https://api',
+      );
+      controller.completeNetwork(id,
+          statusCode: 404, responseBodyPreview: 'nf');
+      final e = container.read(terminalStateProvider).entries.first;
+      expect(e.level, TerminalLevel.error);
+      expect(e.network?.responseStatus, 404);
+      expect(controller.subtitleFor(e), 'nf');
+    });
+
+    test('progress chunks update phase and accumulate data', () {
+      final id = controller.startNetwork(
+        apiType: APIType.rest,
+        method: HTTPVerb.get,
+        url: 'https://chunks',
+        isStreaming: true,
+      );
+      controller.addNetworkChunk(
+        id,
+        BodyChunk(ts: DateTime.now(), text: 'part1', sizeBytes: 5),
+      );
+      controller.addNetworkChunk(
+        id,
+        BodyChunk(ts: DateTime.now(), text: 'part2', sizeBytes: 5),
+      );
+      final e = container.read(terminalStateProvider).entries.first;
+      expect(e.network?.phase, NetworkPhase.progress);
+      expect(e.network?.chunks.length, 2);
+      expect(e.network?.chunks.first.text, 'part1');
+    });
+
+    test('entries are stored newest first and index maps ids', () {
+      controller.logSystem(category: 'a', message: 'm1');
+      controller.logSystem(category: 'b', message: 'm2');
+      final entries = container.read(terminalStateProvider).entries;
+      // Last logged appears first
+      expect(entries.first.system?.category, anyOf('a', 'b'));
+      final idxMap = container.read(terminalStateProvider).index;
+      expect(idxMap.containsKey(entries.first.id), isTrue);
+      expect(idxMap[entries.first.id], 0);
+    });
+
+    test('serializeAll with provided entries includes ISO timestamps', () {
+      final e1 = TerminalEntry(
+        id: 'x1',
+        ts: DateTime.fromMillisecondsSinceEpoch(0, isUtc: true),
+        source: TerminalSource.system,
+        level: TerminalLevel.info,
+        system: SystemLogData(category: 'ui', message: 'hello'),
+      );
+      final e2 = TerminalEntry(
+        id: 'x2',
+        ts: DateTime.fromMillisecondsSinceEpoch(1000, isUtc: true),
+        source: TerminalSource.js,
+        level: TerminalLevel.error,
+        js: JsLogData(level: 'error', args: ['boom']),
+      );
+      final text = controller.serializeAll(entries: [e1, e2]);
+      expect(text, contains('[1970-01-01T00:00:00.000Z]'));
+      expect(text, contains('[1970-01-01T00:00:01.000Z]'));
+      expect(text, contains('System'));
+      expect(text, contains('JS error'));
+    });
+  });
+
+  group('TerminalState.copyWith', () {
+    test('returns same entries when no new entries provided', () {
+      final e1 = TerminalEntry(
+        id: 'id1',
+        source: TerminalSource.system,
+        level: TerminalLevel.info,
+        system: SystemLogData(category: 'ui', message: 'hello'),
+      );
+      final s1 = TerminalState(entries: [e1]);
+      final s2 = s1.copyWith();
+
+      expect(identical(s1.entries, s2.entries), isTrue);
+      expect(s2.index[e1.id], 0);
+      expect(s2.index.length, 1);
+    });
+
+    test('rebuilds index when entries list changes', () {
+      final e1 = TerminalEntry(
+        id: 'id1',
+        source: TerminalSource.system,
+        level: TerminalLevel.info,
+        system: SystemLogData(category: 'ui', message: 'hello'),
+      );
+      final e2 = TerminalEntry(
+        id: 'id2',
+        source: TerminalSource.js,
+        level: TerminalLevel.error,
+        js: JsLogData(level: 'error', args: ['boom']),
+      );
+
+      final s1 = TerminalState(entries: [e1]);
+      final s2 = s1.copyWith(entries: [e2, e1]);
+
+      expect(identical(s1.entries, s2.entries), isFalse);
+      expect(s2.entries, orderedEquals([e2, e1]));
+      expect(s2.index[e2.id], 0);
+      expect(s2.index[e1.id], 1);
+      expect(s2.index.length, 2);
+    });
+  });
+}