Add base error and trycall function, refactored result

Author: NRijnberg

lib/chopper/base_error.dart

@@ -0,0 +1,26 @@
+/// Interface for the errors that could be returned
+interface class BaseError {}
+
+/// The device is not connected error
+class NoInternetError implements BaseError {
+  /// The device is not connected error
+  const NoInternetError();
+}
+
+/// Http client error
+class ServerError implements BaseError {
+  /// Http client error
+  const ServerError();
+}
+
+/// Unknown error
+class UnknownError implements BaseError {
+  /// Unknown error
+  const UnknownError();
+}
+
+/// User not authenticated error
+class AuthenticationFailedError implements BaseError {
+  /// User not authenticated error
+  const AuthenticationFailedError();
+}

lib/common/result/result.dart

@@ -1,15 +1,18 @@
-import 'package:flutter/foundation.dart';
+import 'dart:async';
 
-/// Result class to handle success, failure and loading states.
+import 'package:chopper/chopper.dart';
+import 'package:dcc_toolkit/chopper/base_error.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:http/http.dart';
+
+/// Result class to handle success and failure states.
 @immutable
 sealed class Result<T> {
   const Result();
 
   factory Result.success(T value) => Success(value);
 
-  factory Result.failure(Exception? exception) => Failure(exception);
-
-  factory Result.loading() => Loading<T>();
+  factory Result.failure(BaseError? exception) => Failure(exception);
 
   /// Returns the value if [Result] is [Success] or null otherwise.
   T? get getOrNull => switch (this) {
@@ -18,17 +21,14 @@ sealed class Result<T> {
       };
 
   /// Returns the exception if [Result] is [Failure] or null otherwise.
-  Exception? get exceptionOrNull => switch (this) {
-        Failure(exception: final exception) => exception,
+  BaseError? get errorOrNull => switch (this) {
+        Failure(error: final error) => error,
         _ => null,
       };
 
   /// Returns true if [Result] is [Success].
   bool get isSuccess => this is Success<T>;
 
-  /// Returns true if [Result] is [Loading].
-  bool get isLoading => this is Loading<T>;
-
   /// Returns true if [Result] is [Failure].
   bool get isFailure => this is Failure<T>;
 
@@ -40,19 +40,31 @@ sealed class Result<T> {
     };
   }
 
-  /// Maps the value of [Result] if it is [Success] or returns the same [Result] otherwise.
-  /// This catches any exception thrown by [transform] and returns a [Failure] with the exception.
-  Result<R> mapCatch<R>(R Function(T value) transform) {
-    return switch (this) {
-      Success(value: final value) => () {
-          try {
-            return Result.success(transform(value));
-          } on Exception catch (e) {
-            return Failure<R>(e);
-          }
-        }(),
-      _ => this as Result<R>,
-    };
+  /// Executes the given API call [fn]. When the call succeeds, [Result.success] is returned with the response.
+  /// When the call fails the optional [onError] is executed and the exceptions are handled.
+  /// If there is no [onError] provided, an error of type [BaseError] is returned in [Result.failure].
+  Future<Result<S>> tryCall<S>(
+    FutureOr<S> Function() fn, {
+    Future<Result<S>> Function(Exception error)? onError,
+  }) async {
+    try {
+      return Result.success(await fn());
+    } on Exception catch (e) {
+      if (onError != null) {
+        return onError(e);
+      }
+      return switch (e) {
+        ChopperHttpException() => Result.failure(
+            switch (e.response.statusCode) {
+              401 => const AuthenticationFailedError(),
+              _ => const ServerError(),
+            },
+          ),
+        ClientException() => Result.failure(const NoInternetError()),
+        CheckedFromJsonException() => Result.failure(const ServerError()),
+        _ => Result.failure(const UnknownError()),
+      };
+    }
   }
 }
 
@@ -80,36 +92,20 @@ final class Success<T> extends Result<T> {
 /// Class representing a failed result.
 @immutable
 final class Failure<T> extends Result<T> {
-  /// Creates a [Failure] with the given [exception].
-  const Failure(this.exception);
+  /// Creates a [Failure] with the given [error].
+  const Failure(this.error);
 
   /// The exception of the [Result].
-  final Exception? exception;
+  final BaseError? error;
 
   @override
   bool operator ==(Object other) {
     return identical(this, other) ||
         other is Failure<T> &&
             runtimeType == other.runtimeType &&
-            other.exception == exception;
-  }
-
-  @override
-  int get hashCode => exception.hashCode;
-}
-
-/// Class representing a loading result.
-@immutable
-final class Loading<T> extends Result<T> {
-  /// Creates a [Loading].
-  const Loading();
-
-  @override
-  bool operator ==(Object other) {
-    return identical(this, other) ||
-        other is Loading<T> && runtimeType == other.runtimeType;
+            other.error == error;
   }
 
   @override
-  int get hashCode => 1;
+  int get hashCode => error.hashCode;
 }

pubspec.yaml

@@ -14,13 +14,13 @@ dependencies:
   flutter:
     sdk: flutter
   freezed_annotation: ^2.4.4
+  http: ^1.2.2
   intl: ^0.19.0
   logging: ^1.2.0
 
 dev_dependencies:
   flutter_test:
     sdk: flutter
-  http: ^1.2.2
   mocktail: ^1.0.4
   parameterized_test: ^2.0.0
   very_good_analysis: ^6.0.0

test/common/result/result_test.dart

@@ -1,17 +1,14 @@
+import 'package:dcc_toolkit/chopper/base_error.dart';
 import 'package:dcc_toolkit/common/result/result.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:parameterized_test/parameterized_test.dart';
 
 void main() {
-  final testExceptionResult = Failure<int>(Exception('test'));
+  const testExceptionResult = Failure<int>(ServerError());
   parameterizedTest('comparing 2 results should return true if equal', [
     [const Success<int>(1), const Success<int>(1), true],
     [const Success<int>(1), const Success<int>(2), false],
-    [const Success<int>(1), const Loading<int>(), false],
-    [const Success<int>(1), Failure<int>(Exception('test')), false],
-    [const Loading<int>(), Failure<int>(Exception('test')), false],
-    [const Loading<int>(), const Loading<int>(), true],
-    [Failure<int>(Exception('test')), Failure<int>(Exception('test')), false],
+    [const Success<int>(1), const Failure<int>(ServerError()), false],
     [testExceptionResult, testExceptionResult, true],
   ], (Result<int> result1, Result<int> result2, bool expected) {
     final actual = result1 == result2;
@@ -24,29 +21,19 @@ void main() {
   });
 
   test('getOrNull returns null for Failure', () {
-    final result = Result<int>.failure(Exception('test'));
-    expect(result.getOrNull, null);
-  });
-
-  test('getOrNull returns null for Loading', () {
-    final result = Result<int>.loading();
+    final result = Result<int>.failure(const ServerError());
     expect(result.getOrNull, null);
   });
 
   test('exceptionOrNull returns exception for Failure', () {
-    final exception = Exception('test');
+    const exception = ServerError();
     final result = Result<int>.failure(exception);
-    expect(result.exceptionOrNull, exception);
+    expect(result.errorOrNull, exception);
   });
 
   test('exceptionOrNull returns null for Success', () {
     final result = Result<int>.success(1);
-    expect(result.exceptionOrNull, null);
-  });
-
-  test('exceptionOrNull returns null for Loading', () {
-    final result = Result<int>.loading();
-    expect(result.exceptionOrNull, null);
+    expect(result.errorOrNull, null);
   });
 
   test('isSuccess returns true for Success', () {
@@ -55,32 +42,12 @@ void main() {
   });
 
   test('isSuccess returns false for Failure', () {
-    final result = Result<int>.failure(Exception('test'));
+    final result = Result<int>.failure(const ServerError());
     expect(result.isSuccess, false);
   });
 
-  test('isSuccess returns false for Loading', () {
-    final result = Result<int>.loading();
-    expect(result.isSuccess, false);
-  });
-
-  test('isLoading returns true for Loading', () {
-    final result = Result<int>.loading();
-    expect(result.isLoading, true);
-  });
-
-  test('isLoading returns false for Success', () {
-    final result = Result<int>.success(1);
-    expect(result.isLoading, false);
-  });
-
-  test('isLoading returns false for Failure', () {
-    final result = Result<int>.failure(Exception('test'));
-    expect(result.isLoading, false);
-  });
-
   test('isFailure returns true for Failure', () {
-    final result = Result<int>.failure(Exception('test'));
+    final result = Result<int>.failure(const ServerError());
     expect(result.isFailure, true);
   });
 
@@ -89,50 +56,15 @@ void main() {
     expect(result.isFailure, false);
   });
 
-  test('isFailure returns false for Loading', () {
-    final result = Result<int>.loading();
-    expect(result.isFailure, false);
-  });
-
   test('map transforms value for Success', () {
     final result = Result<int>.success(1);
     final mapped = result.map((value) => value + 1);
     expect(mapped.getOrNull, 2);
   });
 
   test('map does not transform value for Failure', () {
-    final result = Result<int>.failure(Exception('test'));
+    final result = Result<int>.failure(const ServerError());
     final mapped = result.map((value) => value + 1);
     expect(mapped.getOrNull, null);
   });
-
-  test('map does not transform value for Loading', () {
-    final result = Result<int>.loading();
-    final mapped = result.map((value) => value + 1);
-    expect(mapped.getOrNull, null);
-  });
-
-  test('mapCatch transforms value for Success', () {
-    final result = Result<int>.success(1);
-    final mapped = result.mapCatch((value) => value + 1);
-    expect(mapped.getOrNull, 2);
-  });
-
-  test('mapCatch does not transform value for Failure', () {
-    final result = Result<int>.failure(Exception('test'));
-    final mapped = result.mapCatch((value) => value + 1);
-    expect(mapped.getOrNull, null);
-  });
-
-  test('mapCatch does not transform value for Loading', () {
-    final result = Result<int>.loading();
-    final mapped = result.mapCatch((value) => value + 1);
-    expect(mapped.getOrNull, null);
-  });
-
-  test('mapCatch catches exception and returns Failure', () {
-    final result = Result<int>.success(1);
-    final mapped = result.mapCatch((value) => throw Exception('test'));
-    expect(mapped.isFailure, true);
-  });
 }