KataOfKatasWithJDKTest.java

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.*;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;

import static java.util.stream.Collectors.*;

public class KataOfKatasWithJDKTest {

    record KataPerMember<T>(KataJDK kata, T member) {

        interface Builder<T> extends Supplier<Function<KataJDK, Set<T>>> {

            default Stream<KataPerMember<T>> stream(KataJDK kata) {
                return get().apply(kata).stream().map(t -> new KataPerMember<>(kata, t));
            }
        }

        static <T> Builder<T> of(Function<KataJDK, Set<T>> mapper) {
            return () -> mapper;
        }
    }

    record NumberOfKataPerMember<T>(T member, Long count) {

        NumberOfKataPerMember(Map.Entry<T, Long> entry) {
            this(entry.getKey(), entry.getValue());
        }

        public static Comparator<NumberOfKataPerMember<?>> byCount() {
            return Comparator.comparing(NumberOfKataPerMember::count);
        }
    }

    @Test
    void groupKatasByTechnologies() {

        Map<Technology, Set<KataJDK>> katasPerTechnology =
                KataJDK.ALL.stream()
                        .flatMap(KataPerMember.of(KataJDK::getTechnologies)::stream)
                        .collect(collectingAndThen(
                                 groupingBy(KataPerMember::member,
                                            mapping(KataPerMember::kata, toUnmodifiableSet())),
                                 Collections::unmodifiableMap));

        Assertions.assertThatExceptionOfType(UnsupportedOperationException.class)
                .isThrownBy(() -> katasPerTechnology.put(Language.JAVA, Set.of()));
        Assertions.assertThat(katasPerTechnology.get(Language.KOTLIN))
                .containsExactlyInAnyOrder(KataJDK.DECK_OF_CARDS, KataJDK.DONUT);
        Assertions.assertThat(katasPerTechnology.get(Library.ECLIPSE_COLLECTIONS))
                .containsAll(KataJDK.ALL);
    }

    @Test
    void intersectKatasForKotlinAndScala() {

        Map<Language, Set<KataJDK>> katasPerLanguage =
                KataJDK.ALL.stream()
                        .flatMap(KataPerMember.of(KataJDK::getLanguages)::stream)
                        .collect(collectingAndThen(
                                 groupingBy(KataPerMember::member,
                                            mapping(KataPerMember::kata, toUnmodifiableSet())),
                                 Collections::unmodifiableMap));

        Set<KataJDK> intersect = new HashSet<>(katasPerLanguage.get(Language.KOTLIN));
        intersect.retainAll(katasPerLanguage.get(Language.SCALA));

        Assertions.assertThatExceptionOfType(UnsupportedOperationException.class)
                .isThrownBy(() -> katasPerLanguage.put(Language.JAVA, Set.of()));
        Assertions.assertThat(intersect)
                .containsExactly(KataJDK.DECK_OF_CARDS);
    }

    @Test
    void intersectKatasForKotlinAndEclipseCollections() {

        Map<Technology, Set<KataJDK>> katasPerTechnology =
                KataJDK.ALL.stream()
                        .flatMap(KataPerMember.of(KataJDK::getTechnologies)::stream)
                        .collect(collectingAndThen(
                                 groupingBy(KataPerMember::member,
                                            mapping(KataPerMember::kata, toUnmodifiableSet())),
                                 Collections::unmodifiableMap));

        Assertions.assertThatExceptionOfType(UnsupportedOperationException.class)
                .isThrownBy(() -> katasPerTechnology.put(Language.JAVA, Set.of()));
        Set<KataJDK> intersect = new HashSet<>(katasPerTechnology.get(Library.ECLIPSE_COLLECTIONS));
        intersect.retainAll(katasPerTechnology.get(Language.KOTLIN));

        Assertions.assertThat(intersect)
                .containsExactlyInAnyOrder(KataJDK.DONUT, KataJDK.DECK_OF_CARDS);
    }

    @Test
    void intersectKatasForJavaStreamAndEclipseCollections() {

        Map<Library, Set<KataJDK>> katasPerLibrary =
                KataJDK.ALL.stream()
                        .flatMap(KataPerMember.of(KataJDK::getLibraries)::stream)
                        .collect(collectingAndThen(
                                 groupingBy(KataPerMember::member,
                                            mapping(KataPerMember::kata, toUnmodifiableSet())),
                                 Collections::unmodifiableMap));


        Set<KataJDK> intersect = new HashSet<>(katasPerLibrary.get(Library.ECLIPSE_COLLECTIONS));
        intersect.retainAll(katasPerLibrary.get(Library.JAVA_STREAM));

        Assertions.assertThatExceptionOfType(UnsupportedOperationException.class)
                .isThrownBy(() -> katasPerLibrary.put(Library.JAVA_STREAM, Set.of()));
        Assertions.assertThat(intersect)
                .containsExactlyInAnyOrder(KataJDK.DECK_OF_CARDS, KataJDK.PET, KataJDK.JAVA_LAMBDA, KataJDK.CODE_POINT);
    }

    @Test
    void countKatasByLanguages() {

        Map<Language, Long> histogramOfLanguages = KataJDK.ALL.stream()
                .flatMap(KataPerMember.of(KataJDK::getLanguages)::stream)
                .collect(collectingAndThen(
                         groupingBy(KataPerMember::member,
                                    mapping(KataPerMember::kata, counting())),
                         Collections::unmodifiableMap));

        List<NumberOfKataPerMember<Language>> katasPerLibrary =
                histogramOfLanguages
                        .entrySet().stream()
                        .map(NumberOfKataPerMember::new)
                        .sorted(NumberOfKataPerMember.byCount().reversed())
                        .toList();

        Assertions.assertThatExceptionOfType(UnsupportedOperationException.class)
                .isThrownBy(() -> histogramOfLanguages.put(Language.JAVA, 0L));
        Assertions.assertThat(katasPerLibrary.get(0).member())
                .isEqualTo(Language.JAVA);
    }

    @Test
    void countKatasByLibraries() {

        Map<Library, Long> histogramOfLibraries = KataJDK.ALL.stream()
                .flatMap(KataPerMember.of(KataJDK::getLibraries)::stream)
                .collect(collectingAndThen(
                         groupingBy(KataPerMember::member,
                                    mapping(KataPerMember::kata, counting())),
                         Collections::unmodifiableMap));

        List<NumberOfKataPerMember<Library>> katasPerLibrary =
                histogramOfLibraries
                        .entrySet().stream()
                        .map(NumberOfKataPerMember::new)
                        .sorted(NumberOfKataPerMember.byCount().reversed())
                        .toList();

        Assertions.assertThatExceptionOfType(UnsupportedOperationException.class)
                .isThrownBy(() -> histogramOfLibraries.put(Library.JAVA_STREAM, 0L));
        Assertions.assertThat(katasPerLibrary.get(0).member())
                .isEqualTo(Library.ECLIPSE_COLLECTIONS);
    }
}