How to do proper Unit Testing with Chopper

[ratzrattillo]

I am having issues understanding how to do proper Unit testing with Chopper.
The code i am talking about is attached as a zip archive to this discussion, so reproduction is easy!

My current assumptions are

• I am expecting, that the Chopper Service automatically converts Json Responses into concrete Types when i use JsonConverter() as the converter.
• If a response cannot be serialized into the defined type in the service definition, there is an error returned by Chopper.

This is how the API Service is defined:

import 'package:http/http.dart' as http;
import 'package:chopper/chopper.dart';
import 'responses/barrel.dart';

part 'futuresdr_service.chopper.dart';

const String apiUrl = 'http://localhost:4000';

@ChopperApi()
abstract class FutureSDRService extends ChopperService {
  static FutureSDRService create(http.Client client) {
    final chopperClient = ChopperClient(
      baseUrl: Uri.parse(apiUrl),
      client: client,
      interceptors: [HttpLoggingInterceptor()],
      converter: const JsonConverter(),
      errorConverter: const JsonConverter(),
      services: [
        _$FutureSDRService(),
      ],
    );

    return _$FutureSDRService(chopperClient);
  }

  @Get(path: 'capabilities')
  Future<Response<List<DeviceCapabilities>>> getDeviceCapabilities();
}

The class DeviceCapabilities is a freezed class:

import 'package:freezed_annotation/freezed_annotation.dart';

part 'device_capabilities.freezed.dart';
part 'device_capabilities.g.dart';

@freezed
class DeviceCapabilities with _$DeviceCapabilities {
  const factory DeviceCapabilities({
    required String uuid,
    required Map<String, dynamic> args,
    required List<ChannelCapabilities> capabilities,
  }) = _DeviceCapabilities;

  factory DeviceCapabilities.fromJson(Map<String, dynamic> json) =>
      _$DeviceCapabilitiesFromJson(json);
}

@freezed
class ChannelCapabilities with _$ChannelCapabilities {
  const factory ChannelCapabilities({
    required String direction,
    required List<String> antennas,
    @JsonKey(name: 'frequency_components')
    required Map<String, dynamic> frequencyComponents,
    @JsonKey(name: 'gain_elements') required Map<String, dynamic> gainElements,
    @JsonKey(name: 'full_duplex') required bool fullDuplex,
    @JsonKey(name: 'supports_agc') required bool supportsAgc,
    @JsonKey(name: 'frequency_range')
    required Map<String, dynamic> frequencyRange,
    @JsonKey(name: 'sample_rate_range')
    required Map<String, dynamic> sampleRateRange,
    @JsonKey(name: 'gain_range') required Map<String, dynamic> gainRange,
  }) = _ChannelCapabilities;

  factory ChannelCapabilities.fromJson(Map<String, dynamic> json) =>
      _$ChannelCapabilitiesFromJson(json);
}

Currently i make use of a custom MockClient to return the JSON responses. The responses are loaded from assets within the project's assets directory:

import 'dart:io';

import 'package:flutter/services.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';

class MockHttpClientBuilder {
  MockClient generateClient() {
    return MockClient(
      (request) async {
        try {
          final response = await _getResponseByPath(request.url.path);
          return http.Response(response, 200);
        } on PathNotFoundException catch (e) {
          return http.Response(e.message, 404);
        } catch (e) {
          return http.Response('Server Error', 500);
        }
      },
    );
  }

  Future<String> _getResponseByPath(String path) async {
    print(path);
    switch (path) {
      case '/capabilities':
        return await _readResponseFromAsset(
            'assets/network/device_capabilities.json');
      case '/settings':
        return await _readResponseFromAsset(
            'assets/network/device_settings.json');
      default:
        throw PathNotFoundException(path, const OSError());
    }
  }

  Future<String> _readResponseFromAsset(String assetPath) async =>
      rootBundle.loadString(assetPath);
}

The test is currently flawed/incomplete and implemented like this:

import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
//import 'package:http/http.dart' as http;
//import 'package:mockito/annotations.dart';
//import 'package:mockito/mockito.dart';
import 'dart:convert';
import 'package:test/network/futuresdr_service.dart';
import 'package:test/network/responses/barrel.dart';

//import 'futuresdr_service_test.mocks.dart';
import 'mock_http_client_builder.dart';

// Generate a MockClient using the Mockito package.
// Create new instances of this class in each test.
//@GenerateMocks([http.Client])
void main() {
  TestWidgetsFlutterBinding.ensureInitialized();
  group('getDeviceCapabilities', () {
    test('returns an Album if the http call completes successfully', () async {
      final client = MockHttpClientBuilder().generateClient();
      final service = FutureSDRService.create(client);

      final response = await rootBundle.loadString(
          'lib/assets/network/device_capabilities.json',
          cache: false);

      final responseJson = json.decode(response);

      final parsed = List<DeviceCapabilities>.empty(growable: true);
      for (var entry in responseJson) {
        parsed.add(DeviceCapabilities.fromJson(entry));
      }
      print(parsed);

      // Use Mockito to return a successful response when it calls the
      // provided http.Client.
      //client.get(Uri.parse('$apiUrl/capabilities'))
      // service.getDeviceCapabilities()
      //when(client.get(Uri.parse('$apiUrl/capabilities')))
      //    .thenAnswer((_) async => http.Response(response, 200));

      final capabilities = await service.getDeviceCapabilities();
      print(capabilities.isSuccessful);
      print(capabilities.statusCode);
      //print(DeviceCapabilities.fromJson(capabilities.body));

      expect(capabilities.body, isA<List<DeviceCapabilities>>());
    });
  });
}

My questions are:

• Is the approach with the custom MockClient form the class MockHttpClientBuilder() valid or can the same thing done using Mockito?
• How can i properly check in my test that the response from the MockClient represents the DeviceCapabilities-Object loaded from the json file in the assets?
• Does the last check "expect(capabilities.body, isA<List>());" even make sense, when the service is already defined to always return a "List"?

I am looking forward to your responses and maybe some code, to show the most elegant and idomatic way to Unit Test responses returned from a ChopperService with (or without) Mockito.
I am aware of https://hadrien-lejard.gitbook.io/chopper/faq#mock-chopperclient-for-testing but that does not actually answer my questions.

If further details are required please let me know!