createDomainUseCaseTest method

void createDomainUseCaseTest(
  1. String pathTestPage,
  2. String featureName,
  3. String pageName,
  4. List<Map<String, String>> resultModelUnitTest,
)

Implementation

void createDomainUseCaseTest(
  String pathTestPage,
  String featureName,
  String pageName,
  List<Map<String, String>> resultModelUnitTest,
) {
  final path = join(pathTestPage, 'domain', 'usecases');
  DirectoryHelper.createDir(path);

  for (var e in resultModelUnitTest) {
    final apiName = e['apiName'];
    final className = apiName?.pascalCase;
    final methodName = apiName?.camelCase;
    final returnData = e['returnData'] ?? 'model';

    final responseMock = switch (returnData) {
      'header' => '{}',
      'body_bytes' => 'Uint8List(0)',
      'body_string' => "''",
      'status_code' => '200',
      'raw' => 'Response(\'\' , 200)',
      _ => "entity_${className?.snakeCase}.${className}Entity()",
    };

    final expectSuccess = switch (returnData) {
      'header' =>
        '''expect(result, isA<Right<MorphemeFailure, Map<String, String>>>(),);''',
      'body_bytes' =>
        '''expect(result, isA<Right<MorphemeFailure, Uint8List>>(),);''',
      'body_string' =>
        '''expect(result, isA<Right<MorphemeFailure, String>>(),);''',
      'status_code' =>
        '''expect(result, isA<Right<MorphemeFailure, int>>(),);''',
      'raw' =>
        '''expect(result, isA<Right<MorphemeFailure, Response>>(),);''',
      'model' =>
        '''expect(result, isA<Right<MorphemeFailure, entity_${className?.snakeCase}.${className}Entity>>(),);''',
      _ => "''",
    };

    final isMultipart =
        e['method']?.toLowerCase().contains('multipart') ?? false;
    final httpMethod = isMultipart
        ? e['method'] == 'multipart'
            ? 'postMultipart'
            : e['method']
        : e['method'];

    final isCreateTest = whenMethodHttp<bool>(
      httpMethod ?? '',
      onStream: () => false,
      onFuture: () => true,
    );

    if (!isCreateTest) {
      continue;
    }

    join(path, '${apiName?.snakeCase}_use_case_test.dart').write(
        '''// ignore_for_file: prefer_const_constructors, prefer_const_literals_to_create_immutables, unused_local_variable, require_trailing_commas, prefer_single_quotes, prefer_double_quotes

${returnData == 'body_bytes' ? '''import 'dart:typed_data';''' : ''}

import 'package:$featureName/$pageName/domain/repositories/${pageName}_repository.dart';
import 'package:$featureName/$pageName/data/models/body/${apiName?.snakeCase}_body.dart' as body_${e['apiName']?.snakeCase};
${isReturnDataModel(returnData) ? '''import 'package:$featureName/$pageName/domain/entities/${apiName?.snakeCase}_entity.dart' as entity_${e['apiName']?.snakeCase};''' : ''}
import 'package:$featureName/$pageName/domain/usecases/${apiName?.snakeCase}_use_case.dart';
import 'package:core/core.dart';
import 'package:dev_dependency_manager/dev_dependency_manager.dart';

class MockRepository extends Mock implements ${pageName.pascalCase}Repository {}

Future<void> main() async {
late ${className}UseCase usecase;
late MockRepository mockRepository;

setUp(() {
  mockRepository = MockRepository();
  usecase = ${className}UseCase(repository: mockRepository);
});

${getConstOrFinalValue(e['body'] ?? '')} body${e['apiName']?.pascalCase} = ${e['body']}

test(
  'Should fetch entity for the body from the repository',
  () async {
    // arrange
    when(() => mockRepository.$methodName(body$className))
        .thenAnswer((_) async => Right($responseMock));
    // act
    final result = await usecase(body$className);
    // assert
    $expectSuccess
    verify(() => mockRepository.$methodName(body$className));
    verifyNoMoreInteractions(mockRepository);
  },
);
}''');

    StatusHelper.generated(
        join(path, '${apiName?.snakeCase}_use_case_test.dart'));
  }
}