agiledancers/agiledancers-be/src/test/java/nl/agilecc/agiledancers/SnapshotCollectionsTest.java

package nl.agilecc.agiledancers;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import nl.agilecc.agiledancers.model.DanceGroup;
import nl.agilecc.agiledancers.model.scheduling.SchedulingResult;
import nl.agilecc.agiledancers.model.specifications.DanceGroupStyle;
import nl.agilecc.agiledancers.model.specifications.DanceGroupType;
import nl.agilecc.agiledancers.rest.apimodel.GroupRequest;
import nl.agilecc.agiledancers.rest.apimodel.ShowRequest;
import nl.agilecc.agiledancers.service.DanceGroupService;
import nl.agilecc.agiledancers.service.model.Group;
import nl.agilecc.agiledancers.service.model.GroupDetails;
import nl.agilecc.agiledancers.service.model.Person;
import nl.agilecc.agiledancers.service.model.SchoolSnapshot;
import org.junit.jupiter.api.Test;

class SnapshotCollectionsTest {
    @Test
    public void snapshotCopiesCallerOwnedCollectionsAndRetainsInvalidInputForValidation() {
        final List<Person> dancers = new ArrayList<>();
        final SchoolSnapshot snapshot =
                new SchoolSnapshot(2, UUID.randomUUID(), "School", dancers, List.of(), List.of(), List.of());
        dancers.add(new Person("1", "Dancer", null));
        assertEquals(List.of(), snapshot.dancers());
        assertThrows(
                UnsupportedOperationException.class, () -> snapshot.dancers().add(null));
        final SchoolSnapshot invalid =
                new SchoolSnapshot(2, UUID.randomUUID(), "School", null, List.of(), List.of(), List.of());
        assertNull(invalid.dancers());
    }

    @Test
    public void schedulingResultCopiesBothCollectionLevelsAndPreservesMalformedSolverResults() {
        final List<Long> part = new ArrayList<>(List.of(1L));
        final List<List<Long>> assignments = new ArrayList<>(List.of(part));
        final SchedulingResult result = new SchedulingResult(true, assignments);
        part.clear();
        assignments.clear();
        assertEquals(List.of(List.of(1L)), result.assignments());
        assertThrows(
                UnsupportedOperationException.class,
                () -> result.assignments().getFirst().clear());
        assertNull(new SchedulingResult(false, null).assignments());
        final List<List<Long>> invalid = new ArrayList<>();
        invalid.add(null);
        assertNull(new SchedulingResult(false, invalid).assignments().getFirst());
    }

    @Test
    public void requestCollectionsRetainTheirJsonValuesAndCannotBeMutatedThroughAliases() {
        final Map<DanceGroupType, Integer> counts = new LinkedHashMap<>(Map.of(DanceGroupType.REGULAR, 1));
        final ShowRequest show = new ShowRequest("Show", List.of(), counts, null);
        counts.clear();
        assertEquals(1, show.appearances().get(DanceGroupType.REGULAR));
        assertThrows(
                UnsupportedOperationException.class, () -> show.appearances().clear());
        final var styles = new LinkedHashSet<>(List.of(DanceGroupStyle.JAZZ));
        final GroupRequest group = new GroupRequest("Group", DanceGroupType.REGULAR, 0, 99, styles);
        styles.clear();
        assertEquals(1, group.styles().size());
        assertThrows(UnsupportedOperationException.class, () -> group.styles().clear());
    }

    @Test
    public void groupCopiesBothListsWithoutChangingNullableSnapshotValues() {
        final List<DanceGroupStyle> styles = new ArrayList<>(List.of(DanceGroupStyle.JAZZ));
        final List<String> dancerIds = new ArrayList<>(List.of("dancer-1"));
        final Group group = new Group("group-1", "Group", DanceGroupType.REGULAR, 0, 99, styles, dancerIds, null);
        styles.clear();
        dancerIds.clear();
        assertEquals(List.of(DanceGroupStyle.JAZZ), group.styles());
        assertEquals(List.of("dancer-1"), group.dancerIds());
        assertThrows(UnsupportedOperationException.class, () -> group.styles().clear());
        assertThrows(
                UnsupportedOperationException.class, () -> group.dancerIds().clear());
        final Group invalid = new Group("group-2", "Group", DanceGroupType.REGULAR, 0, 99, null, null, null);
        assertNull(invalid.styles());
        assertNull(invalid.dancerIds());
    }

    @Test
    public void groupDetailsCopiesTheStylesPassedAcrossTheServiceBoundary() {
        final var styles = new LinkedHashSet<>(List.of(DanceGroupStyle.JAZZ));
        final GroupDetails details = new GroupDetails("Group", DanceGroupType.REGULAR, 0, 99, styles);
        styles.clear();
        assertEquals(1, details.styles().size());
        assertThrows(UnsupportedOperationException.class, () -> details.styles().clear());
        final DanceGroup group = new DanceGroupService().add(details, new LinkedHashSet<>(), null);
        group.addStyle(DanceGroupStyle.HIPHOP);
        assertEquals(2, group.getStyles().size());
        assertEquals(1, details.styles().size());
        assertNull(new GroupDetails("Group", DanceGroupType.REGULAR, 0, 99, null).styles());
    }
}