Test #8 - 04. Airlines - Performance

import org.softuni.exam.structures.*;

import org.junit.Before;
import org.junit.Test;
import org.softuni.exam.entities.Airline;
import org.softuni.exam.entities.Flight;

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import static org.junit.Assert.*;

public class AirlinesManagerTests8 {
    private interface InternalTest {
        void execute();
    }

    private AirlinesManager airlinesManager;

    private Airline getRandomAirline() {
        return new Airline(
                UUID.randomUUID().toString(),
                UUID.randomUUID().toString(),
                Math.min(1, Math.random() * 1_000_000_000));
    }

    private Flight getRandomFlight() {
        return new Flight(
                UUID.randomUUID().toString(),
                UUID.randomUUID().toString(),
                UUID.randomUUID().toString(),
                UUID.randomUUID().toString(),
                ((Math.random() * 1_000) < 500));
    }

    @Before
    public void setup() {
        this.airlinesManager = new AirlinesManagerImpl();
    }

    public void performCorrectnessTesting(InternalTest[] methods) {
        Arrays.stream(methods)
                .forEach(method -> {
                    this.airlinesManager = new AirlinesManagerImpl();

                    try {
                        method.execute();
                    } catch (IllegalArgumentException ignored) { }
                });

        this.airlinesManager = new AirlinesManagerImpl();
    }

    // Correctness Tests

    private void testAddAirline_ShouldSuccessfullyAddAirline() {
        this.airlinesManager.addAirline(getRandomAirline());
        this.airlinesManager.addAirline(getRandomAirline());
        this.airlinesManager.addAirline(getRandomAirline());

        assertTrue(true);
    }

    private void testAddFlights_ShouldSuccessfullyAddFlight() {
        Airline airline = getRandomAirline();
        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addFlight(airline, getRandomFlight());
        this.airlinesManager.addFlight(airline, getRandomFlight());
        this.airlinesManager.addFlight(airline, getRandomFlight());

        assertTrue(true);
    }

    private void testContains_WithExistentAirline_ShouldReturnTrue() {
        Airline airline = getRandomAirline();
        this.airlinesManager.addAirline(airline);

        assertTrue(this.airlinesManager.contains(airline));
    }

    private void testContains_WithNonExistentAirline_ShouldReturnFalse() {
        Airline airline = getRandomAirline();
        this.airlinesManager.addAirline(airline);

        assertFalse(this.airlinesManager.contains(getRandomAirline()));
    }

    private void testContains_WithExistentFlight_ShouldReturnTrue() {
        Airline airline = getRandomAirline();
        Flight flight = getRandomFlight();
        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addFlight(airline, flight);

        assertTrue(this.airlinesManager.contains(flight));
    }

    private void testContains_WithNonExistentFlight_ShouldReturnFalse() {
        Airline airline = getRandomAirline();
        Flight flight = getRandomFlight();
        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addFlight(airline, flight);

        assertFalse(this.airlinesManager.contains(getRandomFlight()));
    }

    private void testDeleteAirline_WithCorrectData_ShouldProduceCorrectResults() {
        Airline airline = getRandomAirline();
        this.airlinesManager.addAirline(airline);
        this.airlinesManager.deleteAirline(airline);
    }

    private void testDeleteAirline_WithFlights_ShouldProduceCorrectResults() {
        Airline airline = getRandomAirline();
        Flight flight = getRandomFlight();
        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addFlight(airline, flight);
        this.airlinesManager.deleteAirline(airline);
        assertFalse(this.airlinesManager.contains(flight));
    }

    private void testDeleteAirline_WithNoData_ShouldProduceCorrectResults() {
        Airline airline = getRandomAirline();
        this.airlinesManager.addAirline(getRandomAirline());

        // Little bit of hacks
        try {
            this.airlinesManager.deleteAirline(airline);
        } catch (IllegalArgumentException e) {
            assertTrue(true);
            return;
        }

        assertTrue(false);
    }

    private void testAllFlights_WithData_ShouldReturnCorrectResults() {
        Airline airline = getRandomAirline();

        Flight flight1 = getRandomFlight();
        Flight flight2 = getRandomFlight();
        Flight flight3 = getRandomFlight();

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addFlight(airline, flight1);
        this.airlinesManager.addFlight(airline, flight2);
        this.airlinesManager.addFlight(airline, flight3);

        Set<Flight> set =
                StreamSupport.stream(this.airlinesManager.getAllFlights().spliterator(), false)
                        .collect(Collectors.toSet());

        assertEquals(set.size(), 3);
        assertTrue(set.contains(flight1));
        assertTrue(set.contains(flight2));
        assertTrue(set.contains(flight3));
    }

    private void testAllFlights_WithNoData_ShouldReturnCorrectResults() {
        Set<Flight> set =
                StreamSupport.stream(this.airlinesManager.getAllFlights().spliterator(), false)
                        .collect(Collectors.toSet());

        assertEquals(set.size(), 0);
    }

    private void testPerformFlight_WithCorrectData_ShouldReturnCorrectResults() {
        Airline airline = getRandomAirline();

        Flight flight1 = getRandomFlight();

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addFlight(airline, flight1);

        Flight flightPerformed = this.airlinesManager.performFlight(airline, flight1);

        assertEquals(flight1.getId(), flightPerformed.getId());
        assertTrue(flight1.isCompleted());
    }

    private void testPerformFlight_WithNoAirline_ShouldReturnCorrectResults() {
        Airline airline = getRandomAirline();

        Flight flight1 = getRandomFlight();

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addFlight(airline, flight1);

        // Little bit of hacks
        try {
            this.airlinesManager.performFlight(getRandomAirline(), flight1);
        } catch (IllegalArgumentException e) {
            assertTrue(true);
            return;
        }

        assertTrue(false);
    }

    private void testPerformFlight_WithNoAirFlight_ShouldReturnCorrectResults() {
        Airline airline = getRandomAirline();

        Flight flight1 = getRandomFlight();

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addFlight(airline, flight1);

        // Little bit of hacks
        try {
            this.airlinesManager.performFlight(airline, getRandomFlight());
        } catch (IllegalArgumentException e) {
            assertTrue(true);
            return;
        }

        assertTrue(false);
    }

    private void testCompletedFlights_WithData_ShouldReturnCorrectResults() {
        Airline airline = getRandomAirline();
        Airline airline2 = getRandomAirline();

        Flight flight1 = new Flight("a1", "a", "a", "b", false);
        Flight flight2 = new Flight("a2", "a", "a", "b", false);
        Flight flight3 = new Flight("a3", "a", "a", "b", true);

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addAirline(airline2);
        this.airlinesManager.addFlight(airline, flight1);
        this.airlinesManager.addFlight(airline, flight2);
        this.airlinesManager.addFlight(airline2, flight3);
        this.airlinesManager.performFlight(airline, flight1);

        Set<Flight> set =
                StreamSupport.stream(this.airlinesManager.getCompletedFlights().spliterator(), false)
                        .collect(Collectors.toSet());

        assertEquals(set.size(), 2);
        assertTrue(set.contains(flight1));
        assertTrue(set.contains(flight3));
    }

    private void testCompletedFlights_WithNoData_ShouldReturnCorrectResults() {
        Set<Flight> set =
                StreamSupport.stream(this.airlinesManager.getCompletedFlights().spliterator(), false)
                        .collect(Collectors.toSet());

        assertEquals(set.size(), 0);
    }

    private void testFlightsOrdered_WithData_ShouldReturnCorrectResults() {
        Airline airline = getRandomAirline();
        Airline airline2 = getRandomAirline();

        Flight flight1 = new Flight("a1", "d", "a", "b", false);
        Flight flight2 = new Flight("a2", "c", "a", "b", true);
        Flight flight3 = new Flight("a3", "b", "a", "b", true);
        Flight flight4 = new Flight("a4", "a", "a", "b", false);

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addAirline(airline2);
        this.airlinesManager.addFlight(airline, flight1);
        this.airlinesManager.addFlight(airline, flight2);
        this.airlinesManager.addFlight(airline2, flight3);
        this.airlinesManager.addFlight(airline2, flight4);

        List<Flight> list =
                StreamSupport.stream(this.airlinesManager.getFlightsOrderedByNumberThenByCompletion().spliterator(), false)
                        .collect(Collectors.toList());

        assertEquals(list.size(), 4);
        assertEquals(flight4, list.get(0));
        assertEquals(flight1, list.get(1));
        assertEquals(flight3, list.get(2));
        assertEquals(flight2, list.get(3));
    }

    private void testFlightsOrdered_WithNoData_ShouldReturnCorrectResults() {
        List<Flight> list =
                StreamSupport.stream(this.airlinesManager.getFlightsOrderedByNumberThenByCompletion().spliterator(), false)
                        .collect(Collectors.toList());

        assertEquals(list.size(), 0);
    }

    private void testAirlinesOrdered_WithData_ShouldReturnCorrectResults() {
        Airline airline = new Airline("a1", "a2", 4);
        Airline airline2 = new Airline("a2", "a1", 4);
        Airline airline3 = new Airline("a3", "a3", 4);
        Airline airline4 = new Airline("a4", "a4", 10);
        Airline airline5 = new Airline("a5", "a5", 7);

        Flight flight1 = new Flight("a1", "d", "a", "b", false);
        Flight flight2 = new Flight("a2", "c", "a", "b", true);
        Flight flight3 = new Flight("a3", "b", "a", "b", true);
        Flight flight4 = new Flight("a4", "a", "a", "b", false);

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addAirline(airline2);
        this.airlinesManager.addAirline(airline3);
        this.airlinesManager.addAirline(airline4);
        this.airlinesManager.addAirline(airline5);
        this.airlinesManager.addFlight(airline, flight1);
        this.airlinesManager.addFlight(airline, flight2);
        this.airlinesManager.addFlight(airline2, flight3);
        this.airlinesManager.addFlight(airline2, flight4);

        List<Airline> list =
                StreamSupport.stream(this.airlinesManager.getAirlinesOrderedByRatingThenByCountOfFlightsThenByName().spliterator(), false)
                        .collect(Collectors.toList());

        assertEquals(list.size(), 5);
        assertEquals(airline4, list.get(0));
        assertEquals(airline5, list.get(1));
        assertEquals(airline2, list.get(2));
        assertEquals(airline, list.get(3));
        assertEquals(airline3, list.get(4));
    }

    private void testAirlinesOrdered_WithNoData_ShouldReturnCorrectResults() {
        List<Airline> list =
                StreamSupport.stream(this.airlinesManager.getAirlinesOrderedByRatingThenByCountOfFlightsThenByName().spliterator(), false)
                        .collect(Collectors.toList());

        assertEquals(list.size(), 0);
    }

    private void testAirlinesFiltered_WithData_ShouldReturnCorrectResults() {
        Airline airline = new Airline("a1", "a2", 4);
        Airline airline2 = new Airline("a2", "a1", 4);
        Airline airline3 = new Airline("a3", "a3", 4);
        Airline airline4 = new Airline("a4", "a4", 10);
        Airline airline5 = new Airline("a5", "a5", 7);

        Flight flight1 = new Flight("a1", "d", "a1", "b1", false);
        Flight flight2 = new Flight("a2", "c", "a2", "b2", true);
        Flight flight3 = new Flight("a3", "b", "a3", "b2", true);
        Flight flight4 = new Flight("a4", "a", "a2", "b4", false);
        Flight flight5 = new Flight("a5", "F", "a2", "b2", false);

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addAirline(airline2);
        this.airlinesManager.addAirline(airline3);
        this.airlinesManager.addAirline(airline4);
        this.airlinesManager.addAirline(airline5);
        this.airlinesManager.addFlight(airline, flight1);
        this.airlinesManager.addFlight(airline, flight2);
        this.airlinesManager.addFlight(airline2, flight3);
        this.airlinesManager.addFlight(airline2, flight4);
        this.airlinesManager.addFlight(airline3, flight5);

        Set<Airline> set =
                StreamSupport.stream(this.airlinesManager.getAirlinesWithFlightsFromOriginToDestination("a2", "b2").spliterator(), false)
                        .collect(Collectors.toSet());

        assertEquals(set.size(), 1);
        assertTrue(set.contains(airline3));
    }

    private void testAirlinesFiltered_WithNoData_ShouldReturnCorrectResults() {
        Airline airline = new Airline("a1", "a2", 4);
        Airline airline2 = new Airline("a2", "a1", 4);
        Airline airline3 = new Airline("a3", "a3", 4);
        Airline airline4 = new Airline("a4", "a4", 10);
        Airline airline5 = new Airline("a5", "a5", 7);

        Flight flight1 = new Flight("a1", "d", "a1", "b1", false);
        Flight flight2 = new Flight("a2", "c", "a2", "b2", true);
        Flight flight3 = new Flight("a3", "b", "a3", "b2", true);
        Flight flight4 = new Flight("a4", "a", "a2", "b4", false);
        Flight flight5 = new Flight("a5", "F", "a2", "b2", true);

        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addAirline(airline2);
        this.airlinesManager.addAirline(airline3);
        this.airlinesManager.addAirline(airline4);
        this.airlinesManager.addAirline(airline5);
        this.airlinesManager.addFlight(airline, flight1);
        this.airlinesManager.addFlight(airline, flight2);
        this.airlinesManager.addFlight(airline2, flight3);
        this.airlinesManager.addFlight(airline2, flight4);
        this.airlinesManager.addFlight(airline3, flight5);

        List<Airline> list =
                StreamSupport.stream(this.airlinesManager.getAirlinesWithFlightsFromOriginToDestination("a2", "b2").spliterator(), false)
                        .collect(Collectors.toList());

        assertEquals(list.size(), 0);
    }

    // Performance Tests

    @Test
    public void testCompletedFlight_With100000Results_ShouldPassQuickly() {
        this.performCorrectnessTesting(new InternalTest[] {
                this::testCompletedFlights_WithData_ShouldReturnCorrectResults,
                this::testCompletedFlights_WithNoData_ShouldReturnCorrectResults
        });

        int count = 100000;

        Airline airline = getRandomAirline();
        Airline airline2 = getRandomAirline();
        Airline airline3 = getRandomAirline();
        this.airlinesManager.addAirline(airline);
        this.airlinesManager.addAirline(airline2);
        this.airlinesManager.addAirline(airline3);

        for (int i = 0; i < count; i++)
        {
            Flight flightToAdd = new Flight(i + "", i + "number", i + "origin", i + "destination", false);

            if(i < 10000) {
                this.airlinesManager.addFlight(airline, flightToAdd);
            } else if(i < count / 2) {
                flightToAdd.setCompleted(true);
                this.airlinesManager.addFlight(airline2, flightToAdd);
            } else {
                flightToAdd.setCompleted(true);
                this.airlinesManager.addFlight(airline3, flightToAdd);
            }
        }

        long start = System.currentTimeMillis();

        this.airlinesManager.getCompletedFlights();

        long stop = System.currentTimeMillis();

        long elapsedTime = stop - start;

        assertTrue(elapsedTime <= 5);
    }
}