src/test/java/com/packagemanagement/infrastructure/security/JwtTokenProviderTest.java - master - Chebarik/PackageManagement

src/test/java/com/packagemanagement/infrastructure/security/JwtTokenProviderTest.java
166 строк5 KB
Николай Мехоношин
Implemented tests for non functional requirements
14 апр 2026, 18:50
14 апр 2026, 18:509179c8b
package com.packagemanagement.infrastructure.security;

import com.packagemanagement.domain.model.User;
import com.packagemanagement.domain.model.UserRole;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

@DisplayName("JwtTokenProvider")
class JwtTokenProviderTest {

    private static final String SECRET = "TestSecretKeyForJWT2024MustBeAtLeast256BitsLongForHMACSHA!!";
    private static final long EXPIRATION_MS = 3600000;

    private JwtTokenProvider jwtTokenProvider;

    @BeforeEach
    void setUp() {
        jwtTokenProvider = new JwtTokenProvider(SECRET, EXPIRATION_MS);
    }

    private User createUser(String username, UserRole role) {
        return User.create(username, "$2a$10$hash", "test@test.com", role);
    }

    @Nested
    @DisplayName("generateToken")
    class GenerateToken {

        @Test
        @DisplayName("should generate non-null token")
        void shouldGenerateNonNullToken() {
            User user = createUser("john", UserRole.READER);

            String token = jwtTokenProvider.generateToken(user);

            assertNotNull(token);
            assertFalse(token.isEmpty());
        }

        @Test
        @DisplayName("should generate different tokens for different users")
        void shouldGenerateDifferentTokens() {
            User user1 = createUser("john", UserRole.READER);
            User user2 = createUser("jane", UserRole.ADMIN);

            String token1 = jwtTokenProvider.generateToken(user1);
            String token2 = jwtTokenProvider.generateToken(user2);

            assertNotEquals(token1, token2);
        }
    }

    @Nested
    @DisplayName("validateToken")
    class ValidateToken {

        @Test
        @DisplayName("should validate correct token")
        void shouldValidateCorrectToken() {
            User user = createUser("john", UserRole.READER);
            String token = jwtTokenProvider.generateToken(user);

            assertTrue(jwtTokenProvider.validateToken(token));
        }

        @Test
        @DisplayName("should reject malformed token")
        void shouldRejectMalformedToken() {
            assertFalse(jwtTokenProvider.validateToken("not.a.valid.jwt"));
        }

        @Test
        @DisplayName("should reject null token")
        void shouldRejectNullToken() {
            assertFalse(jwtTokenProvider.validateToken(null));
        }

        @Test
        @DisplayName("should reject empty token")
        void shouldRejectEmptyToken() {
            assertFalse(jwtTokenProvider.validateToken(""));
        }

        @Test
        @DisplayName("should reject token signed with different secret")
        void shouldRejectTokenWithDifferentSecret() {
            JwtTokenProvider otherProvider = new JwtTokenProvider(
                    "AnotherSecretKeyThatIsAlsoAtLeast256BitsLongForHMACSHA!!", EXPIRATION_MS);
            User user = createUser("john", UserRole.READER);
            String token = otherProvider.generateToken(user);

            assertFalse(jwtTokenProvider.validateToken(token));
        }

        @Test
        @DisplayName("should reject expired token")
        void shouldRejectExpiredToken() {
            JwtTokenProvider expiredProvider = new JwtTokenProvider(SECRET, -1000);
            User user = createUser("john", UserRole.READER);
            String token = expiredProvider.generateToken(user);

            assertFalse(jwtTokenProvider.validateToken(token));
        }
    }

    @Nested
    @DisplayName("extractUsername")
    class ExtractUsername {

        @Test
        @DisplayName("should extract correct username from token")
        void shouldExtractUsername() {
            User user = createUser("john.doe", UserRole.PUBLISHER);
            String token = jwtTokenProvider.generateToken(user);

            assertEquals("john.doe", jwtTokenProvider.extractUsername(token));
        }
    }

    @Nested
    @DisplayName("extractRole")
    class ExtractRole {

        @Test
        @DisplayName("should extract ROLE_READER for READER user")
        void shouldExtractReaderRole() {
            User user = createUser("reader", UserRole.READER);
            String token = jwtTokenProvider.generateToken(user);

            assertEquals("ROLE_READER", jwtTokenProvider.extractRole(token));
        }

        @Test
        @DisplayName("should extract ROLE_PUBLISHER for PUBLISHER user")
        void shouldExtractPublisherRole() {
            User user = createUser("publisher", UserRole.PUBLISHER);
            String token = jwtTokenProvider.generateToken(user);

            assertEquals("ROLE_PUBLISHER", jwtTokenProvider.extractRole(token));
        }

        @Test
        @DisplayName("should extract ROLE_ADMIN for ADMIN user")
        void shouldExtractAdminRole() {
            User user = createUser("admin", UserRole.ADMIN);
            String token = jwtTokenProvider.generateToken(user);

            assertEquals("ROLE_ADMIN", jwtTokenProvider.extractRole(token));
        }
    }

    @Nested
    @DisplayName("getAccessTokenExpiration")
    class GetExpiration {

        @Test
        @DisplayName("should return expiration in seconds")
        void shouldReturnExpirationInSeconds() {
            assertEquals(3600L, jwtTokenProvider.getAccessTokenExpiration());
        }
    }
}