superport/test/integration/auth_integration_test_fixed.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
import 'package:dio/dio.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart';
import 'package:superport/data/datasources/remote/api_client.dart';
import 'package:superport/data/datasources/remote/auth_remote_datasource.dart';
import 'package:superport/data/models/auth/login_request.dart';
import 'package:superport/data/models/auth/login_response.dart';
import 'package:superport/data/models/auth/auth_user.dart';
import 'package:superport/services/auth_service.dart';
import 'package:superport/core/errors/failures.dart';
import 'package:dartz/dartz.dart';
import 'package:superport/core/config/environment.dart' as env;

import 'auth_integration_test_fixed.mocks.dart';

@GenerateMocks([ApiClient, FlutterSecureStorage])
void main() {
  group('로그인 통합 테스트 (수정본)', () {
    late MockApiClient mockApiClient;
    late MockFlutterSecureStorage mockSecureStorage;
    late AuthRemoteDataSource authRemoteDataSource;
    late AuthService authService;

    setUpAll(() async {
      // 테스트를 위한 환경 초기화
      dotenv.testLoad(mergeWith: {
        'USE_API': 'true',
        'API_BASE_URL': 'https://superport.naturebridgeai.com/api/v1',
        'API_TIMEOUT': '30000',
        'ENABLE_LOGGING': 'false',
      });
      await env.Environment.initialize('test');
    });

    setUp(() {
      mockApiClient = MockApiClient();
      mockSecureStorage = MockFlutterSecureStorage();
      authRemoteDataSource = AuthRemoteDataSourceImpl(mockApiClient);
      
      // AuthServiceImpl에 mock dependencies 주입
      authService = AuthServiceImpl(authRemoteDataSource, mockSecureStorage);
      
      // 기본 mock 설정
      when(mockSecureStorage.write(key: anyNamed('key'), value: anyNamed('value')))
          .thenAnswer((_) async => Future.value());
      when(mockSecureStorage.read(key: anyNamed('key')))
          .thenAnswer((_) async => null);
      when(mockSecureStorage.delete(key: anyNamed('key')))
          .thenAnswer((_) async => Future.value());
    });

    group('성공적인 로그인 시나리오', () {
      test('API가 success/data 형식으로 응답하는 경우', () async {
        // Arrange
        final request = LoginRequest(
          email: 'admin@superport.com',
          password: 'admin123',
        );

        // API 응답 모킹 - snake_case 필드명 사용
        final mockResponse = Response(
          data: {
            'success': true,
            'data': {
              'access_token': 'test_token_123',
              'refresh_token': 'refresh_token_456',
              'token_type': 'Bearer',
              'expires_in': 3600,
              'user': {
                'id': 1,
                'username': 'admin',
                'email': 'admin@superport.com',
                'name': '관리자',
                'role': 'ADMIN',
              },
            },
          },
          statusCode: 200,
          requestOptions: RequestOptions(path: '/auth/login'),
        );

        when(mockApiClient.post(
          '/auth/login',
          data: anyNamed('data'),
          queryParameters: anyNamed('queryParameters'),
          options: anyNamed('options'),
          cancelToken: anyNamed('cancelToken'),
          onSendProgress: anyNamed('onSendProgress'),
          onReceiveProgress: anyNamed('onReceiveProgress'),
        )).thenAnswer((_) async => mockResponse);

        // Act
        final result = await authRemoteDataSource.login(request);

        // Assert
        expect(result.isRight(), true);
        result.fold(
          (failure) => fail('로그인이 실패하면 안됩니다: ${failure.message}'),
          (loginResponse) {
            expect(loginResponse.accessToken, 'test_token_123');
            expect(loginResponse.refreshToken, 'refresh_token_456');
            expect(loginResponse.user.email, 'admin@superport.com');
            expect(loginResponse.user.role, 'ADMIN');
          },
        );

        // Verify API 호출
        verify(mockApiClient.post(
          '/auth/login',
          data: request.toJson(),
        )).called(1);
      });

      test('API가 직접 LoginResponse 형식으로 응답하는 경우', () async {
        // Arrange
        final request = LoginRequest(
          username: 'testuser',
          password: 'password123',
        );

        // 직접 응답 형식 - snake_case 필드명 사용
        final mockResponse = Response(
          data: {
            'access_token': 'direct_token_789',
            'refresh_token': 'direct_refresh_123',
            'token_type': 'Bearer',
            'expires_in': 7200,
            'user': {
              'id': 2,
              'username': 'testuser',
              'email': 'test@example.com',
              'name': '테스트 사용자',
              'role': 'USER',
            },
          },
          statusCode: 200,
          requestOptions: RequestOptions(path: '/auth/login'),
        );

        when(mockApiClient.post(
          '/auth/login',
          data: anyNamed('data'),
          queryParameters: anyNamed('queryParameters'),
          options: anyNamed('options'),
          cancelToken: anyNamed('cancelToken'),
          onSendProgress: anyNamed('onSendProgress'),
          onReceiveProgress: anyNamed('onReceiveProgress'),
        )).thenAnswer((_) async => mockResponse);

        // Act
        final result = await authRemoteDataSource.login(request);

        // Assert
        expect(result.isRight(), true);
        result.fold(
          (failure) => fail('로그인이 실패하면 안됩니다: ${failure.message}'),
          (loginResponse) {
            expect(loginResponse.accessToken, 'direct_token_789');
            expect(loginResponse.refreshToken, 'direct_refresh_123');
            expect(loginResponse.user.username, 'testuser');
            expect(loginResponse.user.role, 'USER');
          },
        );
      });
    });

    group('실패 시나리오', () {
      test('401 인증 실패 응답', () async {
        // Arrange
        final request = LoginRequest(
          email: 'wrong@email.com',
          password: 'wrongpassword',
        );

        when(mockApiClient.post(
          '/auth/login',
          data: anyNamed('data'),
          queryParameters: anyNamed('queryParameters'),
          options: anyNamed('options'),
          cancelToken: anyNamed('cancelToken'),
          onSendProgress: anyNamed('onSendProgress'),
          onReceiveProgress: anyNamed('onReceiveProgress'),
        )).thenThrow(DioException(
          response: Response(
            statusCode: 401,
            statusMessage: 'Unauthorized',
            data: {'message': 'Invalid credentials'},
            requestOptions: RequestOptions(path: '/auth/login'),
          ),
          requestOptions: RequestOptions(path: '/auth/login'),
          type: DioExceptionType.badResponse,
        ));

        // Act
        final result = await authRemoteDataSource.login(request);

        // Assert
        expect(result.isLeft(), true);
        result.fold(
          (failure) {
            expect(failure, isA<AuthenticationFailure>());
            expect(failure.message, contains('올바르지 않습니다'));
          },
          (_) => fail('로그인이 성공하면 안됩니다'),
        );
      });

      test('네트워크 타임아웃', () async {
        // Arrange
        final request = LoginRequest(
          email: 'test@example.com',
          password: 'password',
        );

        when(mockApiClient.post(
          '/auth/login',
          data: anyNamed('data'),
          queryParameters: anyNamed('queryParameters'),
          options: anyNamed('options'),
          cancelToken: anyNamed('cancelToken'),
          onSendProgress: anyNamed('onSendProgress'),
          onReceiveProgress: anyNamed('onReceiveProgress'),
        )).thenThrow(DioException(
          type: DioExceptionType.connectionTimeout,
          message: 'Connection timeout',
          requestOptions: RequestOptions(path: '/auth/login'),
        ));

        // Act
        final result = await authRemoteDataSource.login(request);

        // Assert
        expect(result.isLeft(), true);
        result.fold(
          (failure) {
            expect(failure, isA<ServerFailure>());
            expect(failure.message, contains('오류가 발생했습니다'));
          },
          (_) => fail('로그인이 성공하면 안됩니다'),
        );
      });

      test('잘못된 응답 형식', () async {
        // Arrange
        final request = LoginRequest(
          email: 'test@example.com',
          password: 'password',
        );

        // 잘못된 형식의 응답
        final mockResponse = Response(
          data: {
            'error': 'Invalid request',
            'status': 'failed',
            // 필수 필드들이 누락됨
          },
          statusCode: 200,
          requestOptions: RequestOptions(path: '/auth/login'),
        );

        when(mockApiClient.post(
          '/auth/login',
          data: anyNamed('data'),
          queryParameters: anyNamed('queryParameters'),
          options: anyNamed('options'),
          cancelToken: anyNamed('cancelToken'),
          onSendProgress: anyNamed('onSendProgress'),
          onReceiveProgress: anyNamed('onReceiveProgress'),
        )).thenAnswer((_) async => mockResponse);

        // Act
        final result = await authRemoteDataSource.login(request);

        // Assert
        expect(result.isLeft(), true);
        result.fold(
          (failure) {
            expect(failure, isA<ServerFailure>());
            expect(failure.message, contains('잘못된 응답 형식'));
          },
          (_) => fail('로그인이 성공하면 안됩니다'),
        );
      });
    });

    group('AuthService 통합 테스트', () {
      test('로그인 성공 시 토큰 저장 확인', () async {
        // Arrange
        final request = LoginRequest(
          email: 'admin@superport.com',
          password: 'admin123',
        );

        final mockResponse = Response(
          data: {
            'success': true,
            'data': {
              'access_token': 'saved_token_123',
              'refresh_token': 'saved_refresh_456',
              'token_type': 'Bearer',
              'expires_in': 3600,
              'user': {
                'id': 1,
                'username': 'admin',
                'email': 'admin@superport.com',
                'name': '관리자',
                'role': 'ADMIN',
              },
            },
          },
          statusCode: 200,
          requestOptions: RequestOptions(path: '/auth/login'),
        );

        when(mockApiClient.post(
          '/auth/login',
          data: anyNamed('data'),
          queryParameters: anyNamed('queryParameters'),
          options: anyNamed('options'),
          cancelToken: anyNamed('cancelToken'),
          onSendProgress: anyNamed('onSendProgress'),
          onReceiveProgress: anyNamed('onReceiveProgress'),
        )).thenAnswer((_) async => mockResponse);

        // Act
        final result = await authService.login(request);

        // Assert
        expect(result.isRight(), true);
        
        // 토큰 저장 확인
        verify(mockSecureStorage.write(key: 'access_token', value: 'saved_token_123')).called(1);
        verify(mockSecureStorage.write(key: 'refresh_token', value: 'saved_refresh_456')).called(1);
        verify(mockSecureStorage.write(key: 'user', value: anyNamed('value'))).called(1);
        verify(mockSecureStorage.write(key: 'token_expiry', value: anyNamed('value'))).called(1);
      });

      test('토큰 조회 테스트', () async {
        // Arrange
        when(mockSecureStorage.read(key: 'access_token'))
            .thenAnswer((_) async => 'test_access_token');

        // Act
        final token = await authService.getAccessToken();

        // Assert
        expect(token, 'test_access_token');
        verify(mockSecureStorage.read(key: 'access_token')).called(1);
      });

      test('현재 사용자 조회 테스트', () async {
        // Arrange
        final userJson = '{"id":1,"username":"testuser","email":"test@example.com","name":"테스트 사용자","role":"USER"}';
        when(mockSecureStorage.read(key: 'user'))
            .thenAnswer((_) async => userJson);

        // Act
        final user = await authService.getCurrentUser();

        // Assert
        expect(user, isNotNull);
        expect(user!.id, 1);
        expect(user.username, 'testuser');
        expect(user.email, 'test@example.com');
        expect(user.name, '테스트 사용자');
        expect(user.role, 'USER');
      });
    });
  });
}