superport/test/unit/models/auth_models_test.dart

import 'package:flutter_test/flutter_test.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';

void main() {
  group('Auth Models 단위 테스트', () {
    group('LoginRequest 모델 테스트', () {
      test('이메일로 LoginRequest 생성', () {
        // Arrange & Act
        final request = LoginRequest(
          email: 'test@example.com',
          password: 'password123',
        );

        // Assert
        expect(request.email, 'test@example.com');
        expect(request.username, isNull);
        expect(request.password, 'password123');
      });

      test('username으로 LoginRequest 생성', () {
        // Arrange & Act
        final request = LoginRequest(
          username: 'testuser',
          password: 'password123',
        );

        // Assert
        expect(request.email, isNull);
        expect(request.username, 'testuser');
        expect(request.password, 'password123');
      });

      test('LoginRequest toJson 테스트', () {
        // Arrange
        final request = LoginRequest(
          email: 'test@example.com',
          password: 'password123',
        );

        // Act
        final json = request.toJson();

        // Assert
        expect(json['email'], 'test@example.com');
        expect(json['password'], 'password123');
        // null 값도 JSON에 포함됨
        expect(json.containsKey('username'), isTrue);
        expect(json['username'], isNull);
      });

      test('LoginRequest fromJson 테스트', () {
        // Arrange
        final json = {
          'email': 'test@example.com',
          'password': 'password123',
        };

        // Act
        final request = LoginRequest.fromJson(json);

        // Assert
        expect(request.email, 'test@example.com');
        expect(request.password, 'password123');
      });

      test('LoginRequest 직렬화/역직렬화 라운드트립', () {
        // Arrange
        final original = LoginRequest(
          email: 'test@example.com',
          username: 'testuser',
          password: 'password123',
        );

        // Act
        final json = original.toJson();
        final restored = LoginRequest.fromJson(json);

        // Assert
        expect(restored.email, original.email);
        expect(restored.username, original.username);
        expect(restored.password, original.password);
      });
    });

    group('AuthUser 모델 테스트', () {
      test('AuthUser 생성 및 속성 확인', () {
        // Arrange & Act
        final user = AuthUser(
          id: 1,
          username: 'testuser',
          email: 'test@example.com',
          name: '테스트 사용자',
          role: 'USER',
        );

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

      test('AuthUser toJson 테스트', () {
        // Arrange
        final user = AuthUser(
          id: 1,
          username: 'testuser',
          email: 'test@example.com',
          name: '테스트 사용자',
          role: 'USER',
        );

        // Act
        final json = user.toJson();

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

      test('AuthUser fromJson 테스트', () {
        // Arrange
        final json = {
          'id': 1,
          'username': 'testuser',
          'email': 'test@example.com',
          'name': '테스트 사용자',
          'role': 'USER',
        };

        // Act
        final user = AuthUser.fromJson(json);

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

      test('AuthUser 직렬화/역직렬화 라운드트립', () {
        // Arrange
        final original = AuthUser(
          id: 1,
          username: 'testuser',
          email: 'test@example.com',
          name: '테스트 사용자',
          role: 'USER',
        );

        // Act
        final json = original.toJson();
        final restored = AuthUser.fromJson(json);

        // Assert
        expect(restored, original);
        expect(restored.id, original.id);
        expect(restored.username, original.username);
        expect(restored.email, original.email);
        expect(restored.name, original.name);
        expect(restored.role, original.role);
      });

      test('AuthUser copyWith 테스트', () {
        // Arrange
        final original = AuthUser(
          id: 1,
          username: 'testuser',
          email: 'test@example.com',
          name: '테스트 사용자',
          role: 'USER',
        );

        // Act
        final modified = original.copyWith(
          name: '수정된 사용자',
          role: 'ADMIN',
        );

        // Assert
        expect(modified.id, original.id);
        expect(modified.username, original.username);
        expect(modified.email, original.email);
        expect(modified.name, '수정된 사용자');
        expect(modified.role, 'ADMIN');
      });
    });

    group('LoginResponse 모델 테스트', () {
      test('LoginResponse 생성 및 속성 확인', () {
        // Arrange & Act
        final authUser = AuthUser(
          id: 1,
          username: 'testuser',
          email: 'test@example.com',
          name: '테스트 사용자',
          role: 'USER',
        );

        final response = LoginResponse(
          accessToken: 'test_access_token',
          refreshToken: 'test_refresh_token',
          tokenType: 'Bearer',
          expiresIn: 3600,
          user: authUser,
        );

        // Assert
        expect(response.accessToken, 'test_access_token');
        expect(response.refreshToken, 'test_refresh_token');
        expect(response.tokenType, 'Bearer');
        expect(response.expiresIn, 3600);
        expect(response.user, authUser);
      });

      test('LoginResponse toJson 테스트', () {
        // Arrange
        final authUser = AuthUser(
          id: 1,
          username: 'testuser',
          email: 'test@example.com',
          name: '테스트 사용자',
          role: 'USER',
        );

        final response = LoginResponse(
          accessToken: 'test_access_token',
          refreshToken: 'test_refresh_token',
          tokenType: 'Bearer',
          expiresIn: 3600,
          user: authUser,
        );

        // Act
        final json = response.toJson();

        // Assert - snake_case 필드명 사용
        expect(json['access_token'], 'test_access_token');
        expect(json['refresh_token'], 'test_refresh_token');
        expect(json['token_type'], 'Bearer');
        expect(json['expires_in'], 3600);
        expect(json['user'], authUser); // user는 AuthUser 객체로 포함됨
      });

      test('LoginResponse fromJson 테스트', () {
        // Arrange - snake_case 필드명 사용
        final json = {
          'access_token': 'test_access_token',
          'refresh_token': 'test_refresh_token',
          'token_type': 'Bearer',
          'expires_in': 3600,
          'user': {
            'id': 1,
            'username': 'testuser',
            'email': 'test@example.com',
            'name': '테스트 사용자',
            'role': 'USER',
          },
        };

        // Act
        final response = LoginResponse.fromJson(json);

        // Assert
        expect(response.accessToken, 'test_access_token');
        expect(response.refreshToken, 'test_refresh_token');
        expect(response.tokenType, 'Bearer');
        expect(response.expiresIn, 3600);
        expect(response.user.email, 'test@example.com');
      });

      test('LoginResponse 직렬화/역직렬화 라운드트립', () {
        // Arrange
        final authUser = AuthUser(
          id: 1,
          username: 'testuser',
          email: 'test@example.com',
          name: '테스트 사용자',
          role: 'USER',
        );

        final original = LoginResponse(
          accessToken: 'test_access_token',
          refreshToken: 'test_refresh_token',
          tokenType: 'Bearer',
          expiresIn: 3600,
          user: authUser,
        );

        // Act
        final json = original.toJson();
        // toJson은 user를 AuthUser 객체로 반환하므로 직렬화 필요
        final jsonWithSerializedUser = {
          ...json,
          'user': (json['user'] as AuthUser).toJson(),
        };
        final restored = LoginResponse.fromJson(jsonWithSerializedUser);

        // Assert
        expect(restored.accessToken, original.accessToken);
        expect(restored.refreshToken, original.refreshToken);
        expect(restored.tokenType, original.tokenType);
        expect(restored.expiresIn, original.expiresIn);
        expect(restored.user.id, original.user.id);
        expect(restored.user.email, original.user.email);
      });

      test('camelCase 필드명 호환성 테스트', () {
        // Arrange - API가 camelCase를 사용하는 경우
        final json = {
          'accessToken': 'test_access_token',
          'refreshToken': 'test_refresh_token',
          'tokenType': 'Bearer',
          'expiresIn': 3600,
          'user': {
            'id': 1,
            'username': 'testuser',
            'email': 'test@example.com',
            'name': '테스트 사용자',
            'role': 'USER',
          },
        };

        // Act & Assert - camelCase는 지원되지 않음
        expect(
          () => LoginResponse.fromJson(json),
          throwsA(isA<TypeError>()),
        );
      });
    });

    group('타입 안정성 테스트', () {
      test('null 값 처리 테스트', () {
        // Arrange
        final json = {
          'id': null,
          'username': null,
          'email': 'test@example.com',
          'name': null,
          'role': null,
        };

        // Act & Assert
        expect(() => AuthUser.fromJson(json), throwsA(isA<TypeError>()));
      });

      test('잘못된 타입 처리 테스트', () {
        // Arrange
        final json = {
          'id': '문자열ID', // 숫자여야 함
          'username': 'testuser',
          'email': 'test@example.com',
          'name': '테스트 사용자',
          'role': 'USER',
        };

        // Act & Assert
        expect(() => AuthUser.fromJson(json), throwsA(isA<TypeError>()));
      });

      test('필수 필드 누락 테스트', () {
        // Arrange
        final json = {
          'id': 1,
          'username': 'testuser',
          // email 누락
          'name': '테스트 사용자',
          'role': 'USER',
        };

        // Act & Assert
        expect(() => AuthUser.fromJson(json), throwsA(isA<TypeError>()));
      });
    });
  });
}