Add unit tests

Author: ashtanko

lib/utils/context.dart lib/utils/string_resources.dartlib/utils/context.dart renamed to lib/utils/string_resources.dart

@@ -1 +1 @@
-export 'context.dart';
+export 'string_resources.dart';

lib/utils/utils.dart

@@ -1,28 +1,60 @@
-import 'dart:ffi';
-
 import 'package:flutter_bloc_app_template/data/network/api_result.dart';
 import 'package:flutter_test/flutter_test.dart';
 
 void main() {
   group('ApiResult', () {
-    test('success should contain correct data', () {
-      final result = const ApiResult.success('Test Data');
+    test('should return success result with correct data', () {
+      const result = ApiResult.success(42);
+
+      final output = ApiResultWhen(result).when(
+        success: (data) => 'Success with $data',
+        error: (message) => 'Error: $message',
+        loading: () => 'Loading...',
+      );
 
-      expect(result, isA<Success<String>>());
-      expect((result as Success<String>).data, 'Test Data');
+      expect(output, 'Success with 42');
     });
 
-    test('error should contain correct message', () {
-      final result = const ApiResult<String>.error('Test Error');
+    test('should return error result with correct message', () {
+      const result = ApiResult<String>.error('Something went wrong');
+
+      final output = ApiResultWhen(result).when(
+        success: (data) => 'Success with $data',
+        error: (message) => 'Error: $message',
+        loading: () => 'Loading...',
+      );
 
-      expect(result, isA<Error<String>>());
-      expect((result as Error<String>).message, 'Test Error');
+      expect(output, 'Error: Something went wrong');
     });
 
-    test('loading should be of type Loading', () {
-      final result = const ApiResult<Void>.loading();
+    test('should return loading result', () {
+      const result = ApiResult<String>.loading();
 
-      expect(result, isA<Loading<Void>>());
+      final output = ApiResultWhen(result).when(
+        success: (data) => 'Success with $data',
+        error: (message) => 'Error: $message',
+        loading: () => 'Loading...',
+      );
+
+      expect(output, 'Loading...');
+    });
+
+    test('should throw assertion error for unknown type', () {
+      final invalid = const _InvalidApiResult<int>();
+
+      expect(
+        () => ApiResultWhen(invalid).when(
+          success: (data) => 'Success with $data',
+          error: (message) => 'Error: $message',
+          loading: () => 'Loading...',
+        ),
+        throwsA(isA<AssertionError>()),
+      );
     });
   });
 }
+
+/// A fake invalid implementation to test the fallback case in `when`
+class _InvalidApiResult<T> implements ApiResult<T> {
+  const _InvalidApiResult();
+}

test/data/network/api_result_test.dart

@@ -0,0 +1,48 @@
+import 'package:flutter_bloc_app_template/utils/pair.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('Pair', () {
+    test('should store and expose first and second values', () {
+      const pair = Pair<int, String>(1, 'one');
+
+      expect(pair.first, 1);
+      expect(pair.second, 'one');
+    });
+
+    test('should have correct toString representation', () {
+      const pair = Pair<int, String>(1, 'one');
+
+      expect(pair.toString(), 'Pair(1, one)');
+    });
+
+    test('should compare equal for identical values', () {
+      const a = Pair<int, String>(1, 'one');
+      const b = Pair<int, String>(1, 'one');
+
+      expect(a, equals(b));
+      expect(a.hashCode, equals(b.hashCode));
+    });
+
+    test('should not be equal if first or second values differ', () {
+      const a = Pair<int, String>(1, 'one');
+      const b = Pair<int, String>(2, 'one');
+      const c = Pair<int, String>(1, 'two');
+
+      expect(a == b, isFalse);
+      expect(a == c, isFalse);
+    });
+
+    test('should be equal if identical (same instance)', () {
+      const pair = Pair(1, 'one');
+
+      expect(pair == pair, isTrue);
+    });
+
+    test('should not be equal to unrelated types', () {
+      const pair = Pair(1, 'one');
+
+      expect(pair, isNot(equals('Pair(1, one)')));
+    });
+  });
+}