superport/test/domain/usecases/license/create_license_usecase_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/mockito.dart';
import 'package:mockito/annotations.dart';
import 'package:dartz/dartz.dart';
import 'package:superport/models/license_model.dart';
import 'package:superport/domain/repositories/license_repository.dart';
import 'package:superport/domain/usecases/base_usecase.dart';
import 'package:superport/domain/usecases/license/create_license_usecase.dart';
import 'package:superport/core/errors/failures.dart';

import 'create_license_usecase_test.mocks.dart';

@GenerateMocks([LicenseRepository])
void main() {
  late CreateLicenseUseCase useCase;
  late MockLicenseRepository mockRepository;

  setUp(() {
    mockRepository = MockLicenseRepository();
    useCase = CreateLicenseUseCase(mockRepository);
  });

  group('CreateLicenseUseCase', () {
    final validParams = CreateLicenseParams(
      licenseKey: 'TEST-KEY-001',
      productName: 'Test Product',
      vendor: 'Test Vendor',
      licenseType: 'maintenance',
      userCount: 10,
      purchaseDate: DateTime(2025, 1, 1),
      expiryDate: DateTime(2025, 12, 31),
      purchasePrice: 1000.0,
      companyId: 1,
      branchId: 1,
      remark: 'Test license',
    );

    final mockLicense = License(
      id: 1,
      licenseKey: 'TEST-LICENSE-KEY',
      productName: 'Test Product',
      vendor: 'Test Vendor',
      licenseType: 'maintenance',
      userCount: 10,
      purchaseDate: DateTime(2025, 1, 1),
      expiryDate: DateTime(2025, 12, 31),
      purchasePrice: 1000.0,
      companyId: 1,
      branchId: 1,
      assignedUserId: 1,
      remark: 'Test license',
      isActive: true,
      createdAt: DateTime.now(),
      updatedAt: DateTime.now(),
    );

    test('라이선스 생성 성공', () async {
      // arrange
      when(mockRepository.createLicense(any))
          .thenAnswer((_) async => Right(mockLicense));

      // act
      final result = await useCase(validParams);

      // assert
      expect(result.isRight(), true);
      result.fold(
        (failure) => fail('Should not return failure'),
        (license) => expect(license.id, equals(mockLicense.id)),
      );
      verify(mockRepository.createLicense(any)).called(1);
    });

    test('만료일이 구매일보다 이전인 경우 검증 실패', () async {
      // arrange
      final invalidParams = CreateLicenseParams(
        licenseKey: 'TEST-KEY-002',
        productName: 'Test Product',
        companyId: 1,
        licenseType: 'maintenance',
        purchaseDate: DateTime(2025, 12, 31),
        expiryDate: DateTime(2025, 1, 1), // 구매일보다 이전
        remark: 'Test license',
      );

      // act
      final result = await useCase(invalidParams);

      // assert
      expect(result.isLeft(), true);
      result.fold(
        (failure) {
          expect(failure, isA<ValidationFailure>());
          expect(failure.message, contains('만료일은 구매일 이후여야 합니다'));
        },
        (license) => fail('Should not return license'),
      );
      verifyNever(mockRepository.createLicense(any));
    });

    test('라이선스 기간이 30일 미만인 경우 검증 실패', () async {
      // arrange
      final invalidParams = CreateLicenseParams(
        licenseKey: 'TEST-KEY-003',
        productName: 'Test Product',
        companyId: 1,
        licenseType: 'maintenance',
        purchaseDate: DateTime(2025, 1, 1),
        expiryDate: DateTime(2025, 1, 15), // 15일 기간
        remark: 'Test license',
      );

      // act
      final result = await useCase(invalidParams);

      // assert
      expect(result.isLeft(), true);
      result.fold(
        (failure) {
          expect(failure, isA<ValidationFailure>());
          expect(failure.message, contains('라이선스 기간은 최소 30일 이상이어야 합니다'));
        },
        (license) => fail('Should not return license'),
      );
      verifyNever(mockRepository.createLicense(any));
    });

    test('Repository에서 예외 발생 시 ServerFailure 반환', () async {
      // arrange
      when(mockRepository.createLicense(any))
          .thenAnswer((_) async => Left(ServerFailure(message: 'Server error')));

      // act
      final result = await useCase(validParams);

      // assert
      expect(result.isLeft(), true);
      result.fold(
        (failure) {
          expect(failure, isA<ServerFailure>());
          expect(failure.message, contains('Server error'));
        },
        (license) => fail('Should not return license'),
      );
      verify(mockRepository.createLicense(any)).called(1);
    });

    test('옵셔널 파라미터가 null인 경우에도 정상 처리', () async {
      // arrange
      final paramsWithNulls = CreateLicenseParams(
        licenseKey: 'TEST-KEY-004',
        productName: 'Test Product',
        companyId: 1,
        purchaseDate: DateTime(2025, 1, 1),
        expiryDate: DateTime(2025, 12, 31),
        vendor: null,
        licenseType: null,
        userCount: null,
        purchasePrice: null,
        branchId: null,
        remark: null,
      );

      when(mockRepository.createLicense(any))
          .thenAnswer((_) async => Right(mockLicense));

      // act
      final result = await useCase(paramsWithNulls);

      // assert
      expect(result.isRight(), true);
      verify(mockRepository.createLicense(any)).called(1);
    });
  });
}