src/test/java/com/packagemanagement/domain/model/PackageTest.java - master - Chebarik/PackageManagement

src/test/java/com/packagemanagement/domain/model/PackageTest.java
326 строк11 KB
Николай Мехоношин
added unit tests
13 янв 2026, 20:50
13 янв 2026, 20:50d22b6a7
package com.packagemanagement.domain.model;

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 java.time.Instant;
import java.util.Optional;

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

@DisplayName("Package Aggregate Root")
class PackageTest {

    @Nested
    @DisplayName("Creation")
    class Creation {

        @Test
        @DisplayName("should create package with valid parameters")
        void shouldCreatePackageWithValidParameters() {
            Package pkg = Package.create("my-package", "A test package", PackageFormat.NUGET);
            
            assertNotNull(pkg);
            assertNotNull(pkg.getId());
            assertEquals("my-package", pkg.getName());
            assertEquals("A test package", pkg.getDescription());
            assertEquals(PackageFormat.NUGET, pkg.getFormat());
            assertTrue(pkg.getVersions().isEmpty());
            assertNotNull(pkg.getCreatedAt());
            assertNotNull(pkg.getUpdatedAt());
        }

        @Test
        @DisplayName("should create Maven package")
        void shouldCreateMavenPackage() {
            Package pkg = Package.create("java-lib", "Java library", PackageFormat.MAVEN);
            
            assertEquals(PackageFormat.MAVEN, pkg.getFormat());
        }

        @Test
        @DisplayName("should throw exception for null name")
        void shouldThrowExceptionForNullName() {
            assertThrows(IllegalArgumentException.class, () -> 
                Package.create(null, "description", PackageFormat.NUGET)
            );
        }

        @Test
        @DisplayName("should throw exception for blank name")
        void shouldThrowExceptionForBlankName() {
            assertThrows(IllegalArgumentException.class, () -> 
                Package.create("", "description", PackageFormat.NUGET)
            );
        }

        @Test
        @DisplayName("should throw exception for invalid name characters")
        void shouldThrowExceptionForInvalidNameCharacters() {
            assertThrows(IllegalArgumentException.class, () -> 
                Package.create("my package!", "description", PackageFormat.NUGET)
            );
        }

        @Test
        @DisplayName("should throw exception for name exceeding 100 characters")
        void shouldThrowExceptionForLongName() {
            String longName = "a".repeat(101);
            assertThrows(IllegalArgumentException.class, () -> 
                Package.create(longName, "description", PackageFormat.NUGET)
            );
        }

        @Test
        @DisplayName("should throw exception for null format")
        void shouldThrowExceptionForNullFormat() {
            assertThrows(NullPointerException.class, () -> 
                Package.create("my-package", "description", null)
            );
        }

        @Test
        @DisplayName("should accept valid package names")
        void shouldAcceptValidPackageNames() {
            assertDoesNotThrow(() -> Package.create("my-package", "desc", PackageFormat.NUGET));
            assertDoesNotThrow(() -> Package.create("my_package", "desc", PackageFormat.NUGET));
            assertDoesNotThrow(() -> Package.create("my.package", "desc", PackageFormat.NUGET));
            assertDoesNotThrow(() -> Package.create("MyPackage123", "desc", PackageFormat.NUGET));
        }
    }

    @Nested
    @DisplayName("Version Management")
    class VersionManagement {

        private Package pkg;

        @BeforeEach
        void setUp() {
            pkg = Package.create("test-package", "Test", PackageFormat.NUGET);
        }

        @Test
        @DisplayName("should add version to package")
        void shouldAddVersionToPackage() {
            PackageVersion version = PackageVersion.create("1.0.0", 1024L, "hash");
            
            pkg.addVersion(version);
            
            assertEquals(1, pkg.getVersionCount());
            assertTrue(pkg.findVersion("1.0.0").isPresent());
        }

        @Test
        @DisplayName("should not add duplicate version")
        void shouldNotAddDuplicateVersion() {
            PackageVersion v1 = PackageVersion.create("1.0.0", 1024L, "hash1");
            PackageVersion v2 = PackageVersion.create("1.0.0", 2048L, "hash2");
            
            pkg.addVersion(v1);
            
            assertThrows(IllegalArgumentException.class, () -> pkg.addVersion(v2));
        }

        @Test
        @DisplayName("should add multiple different versions")
        void shouldAddMultipleDifferentVersions() {
            pkg.addVersion(PackageVersion.create("1.0.0", 1024L, "hash1"));
            pkg.addVersion(PackageVersion.create("1.1.0", 1024L, "hash2"));
            pkg.addVersion(PackageVersion.create("2.0.0", 1024L, "hash3"));
            
            assertEquals(3, pkg.getVersionCount());
        }

        @Test
        @DisplayName("should remove draft version")
        void shouldRemoveDraftVersion() {
            PackageVersion version = PackageVersion.create("1.0.0", 1024L, "hash");
            pkg.addVersion(version);
            
            pkg.removeVersion("1.0.0");
            
            assertEquals(0, pkg.getVersionCount());
            assertTrue(pkg.findVersion("1.0.0").isEmpty());
        }

        @Test
        @DisplayName("should remove published version (MVP)")
        void shouldRemovePublishedVersion() {
            PackageVersion version = PackageVersion.create("1.0.0", 1024L, "hash");
            version.publish();
            pkg.addVersion(version);
            
            pkg.removeVersion("1.0.0");
            
            assertEquals(0, pkg.getVersionCount());
        }

        @Test
        @DisplayName("should throw exception when removing non-existent version")
        void shouldThrowExceptionWhenRemovingNonExistentVersion() {
            assertThrows(IllegalArgumentException.class, () -> pkg.removeVersion("1.0.0"));
        }

        @Test
        @DisplayName("should find version by number")
        void shouldFindVersionByNumber() {
            PackageVersion version = PackageVersion.create("1.0.0", 1024L, "hash");
            pkg.addVersion(version);
            
            Optional<PackageVersion> found = pkg.findVersion("1.0.0");
            
            assertTrue(found.isPresent());
            assertEquals("1.0.0", found.get().getVersionNumber());
        }

        @Test
        @DisplayName("should return empty when version not found")
        void shouldReturnEmptyWhenVersionNotFound() {
            Optional<PackageVersion> found = pkg.findVersion("1.0.0");
            
            assertTrue(found.isEmpty());
        }

        @Test
        @DisplayName("should get highest version")
        void shouldGetHighestVersion() {
            pkg.addVersion(PackageVersion.create("1.0.0", 1024L, "hash1"));
            pkg.addVersion(PackageVersion.create("2.0.0", 1024L, "hash2"));
            pkg.addVersion(PackageVersion.create("1.5.0", 1024L, "hash3"));
            
            Optional<PackageVersion> highest = pkg.getHighestVersion();
            
            assertTrue(highest.isPresent());
            assertEquals("2.0.0", highest.get().getVersionNumber());
        }

        @Test
        @DisplayName("should get latest published version")
        void shouldGetLatestPublishedVersion() {
            PackageVersion v1 = PackageVersion.create("1.0.0", 1024L, "hash1");
            v1.publish();
            PackageVersion v2 = PackageVersion.create("2.0.0", 1024L, "hash2");

            pkg.addVersion(v1);
            pkg.addVersion(v2);
            
            Optional<PackageVersion> latest = pkg.getLatestVersion();
            
            assertTrue(latest.isPresent());
            assertEquals("1.0.0", latest.get().getVersionNumber());
        }

        @Test
        @DisplayName("should update timestamp when adding version")
        void shouldUpdateTimestampWhenAddingVersion() {
            Instant before = pkg.getUpdatedAt();
            
            try { Thread.sleep(10); } catch (InterruptedException ignored) {}
            
            pkg.addVersion(PackageVersion.create("1.0.0", 1024L, "hash"));
            
            assertTrue(pkg.getUpdatedAt().isAfter(before) || pkg.getUpdatedAt().equals(before));
        }
    }

    @Nested
    @DisplayName("Metadata Update")
    class MetadataUpdate {

        @Test
        @DisplayName("should update name")
        void shouldUpdateName() {
            Package pkg = Package.create("old-name", "description", PackageFormat.NUGET);
            
            pkg.updateMetadata("new-name", null);
            
            assertEquals("new-name", pkg.getName());
        }

        @Test
        @DisplayName("should update description")
        void shouldUpdateDescription() {
            Package pkg = Package.create("my-package", "old description", PackageFormat.NUGET);
            
            pkg.updateMetadata(null, "new description");
            
            assertEquals("new description", pkg.getDescription());
        }

        @Test
        @DisplayName("should not update name if blank")
        void shouldNotUpdateNameIfBlank() {
            Package pkg = Package.create("my-package", "description", PackageFormat.NUGET);
            
            pkg.updateMetadata("", null);
            
            assertEquals("my-package", pkg.getName());
        }
    }

    @Nested
    @DisplayName("Published Versions Check")
    class PublishedVersionsCheck {

        @Test
        @DisplayName("should return false when no versions")
        void shouldReturnFalseWhenNoVersions() {
            Package pkg = Package.create("my-package", "description", PackageFormat.NUGET);
            
            assertFalse(pkg.hasPublishedVersions());
        }

        @Test
        @DisplayName("should return false when only draft versions")
        void shouldReturnFalseWhenOnlyDraftVersions() {
            Package pkg = Package.create("my-package", "description", PackageFormat.NUGET);
            pkg.addVersion(PackageVersion.create("1.0.0", 1024L, "hash"));
            
            assertFalse(pkg.hasPublishedVersions());
        }

        @Test
        @DisplayName("should return true when has published version")
        void shouldReturnTrueWhenHasPublishedVersion() {
            Package pkg = Package.create("my-package", "description", PackageFormat.NUGET);
            PackageVersion version = PackageVersion.create("1.0.0", 1024L, "hash");
            version.publish();
            pkg.addVersion(version);
            
            assertTrue(pkg.hasPublishedVersions());
        }
    }

    @Nested
    @DisplayName("Equality")
    class Equality {

        @Test
        @DisplayName("packages with same id should be equal")
        void packagesWithSameIdShouldBeEqual() {
            Instant now = Instant.now();
            PackageId id = PackageId.of("same-id");
            
            Package p1 = Package.builder()
                    .id(id)
                    .name("package-1")
                    .format(PackageFormat.NUGET)
                    .createdAt(now)
                    .updatedAt(now)
                    .build();
            
            Package p2 = Package.builder()
                    .id(id)
                    .name("package-2")
                    .format(PackageFormat.MAVEN)
                    .createdAt(now)
                    .updatedAt(now)
                    .build();
            
            assertEquals(p1, p2);
        }
    }
}