MyINPulse/MyINPulse-back/src/test/java/enseirb/myinpulse/AdminApiServiceTest.java

package enseirb.myinpulse;

import static enseirb.myinpulse.model.ProjectDecisionValue.*;

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

import enseirb.myinpulse.model.Administrator;
import enseirb.myinpulse.model.Entrepreneur;
import enseirb.myinpulse.model.Project;
import enseirb.myinpulse.model.ProjectDecision;
import enseirb.myinpulse.service.AdminApiService;
import enseirb.myinpulse.service.database.AdministratorService;
import enseirb.myinpulse.service.database.EntrepreneurService;
import enseirb.myinpulse.service.database.ProjectService;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.server.ResponseStatusException;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

@SpringBootTest
@Transactional
public class AdminApiServiceTest {
    private static long administratorid;
    private static Administrator administrator;
    private static Entrepreneur entrepreneur;
    @Autowired private AdminApiService adminApiService;
    @Autowired private ProjectService projectService;

    @BeforeAll
    static void setup(
            @Autowired AdministratorService administratorService,
            @Autowired ProjectService projectService,
            @Autowired EntrepreneurService entrepreneurService) {
        administratorService.addAdministrator(
                new Administrator(
                        "admin",
                        "admin",
                        "testAdminEmpty@example.com",
                        "testAdmin@example.com",
                        ""));
        administrator =
                administratorService.addAdministrator(
                        new Administrator(
                                "admin2",
                                "admin2",
                                "testAdminFull@example.com",
                                "testAdmin@example.com",
                                ""));
        administratorid = administrator.getIdUser();
        entrepreneur =
                new Entrepreneur(
                        "JeSuisUnEntrepreneurDeCompet",
                        "EtUé",
                        "Entrepreneur@inpulse.com",
                        "mail2",
                        "phone",
                        "Ensimag    nan jdeconne ENSEIRB (-matmeca mais on s'en fout)",
                        "info ofc",
                        false);
        entrepreneurService.addEntrepreneur(entrepreneur);
        projectService.addNewProject(
                new Project(
                        "sampleProjectAdminApiService",
                        null,
                        LocalDate.now(),
                        ACTIVE,
                        administratorService.getAdministratorByPrimaryMain(
                                "testAdminFull@example.com")));
    }

    private <T> List<T> IterableToList(Iterable<T> iterable) {
        List<T> l = new ArrayList<>();
        iterable.forEach(l::add);
        return l;
    }

    @Test
    void getProjectOfAdminIsEmpty() {
        Iterable<Project> projects =
                adminApiService.getProjectsOfAdmin("testAdminEmpty@example.com");
        assertEquals(0, IterableToList(projects).size());
    }

    @Test
    void getProjectOfInexistantAdminFails() {
        String nonExistentAdminEmail = "testInexistantAdmin@example.com";

        assertThrows(
                ResponseStatusException.class,
                () -> {
                    adminApiService.getProjectsOfAdmin(nonExistentAdminEmail);
                });
    }

    @Test
    void getProjectOfAdminNotEmpty() {
        Iterable<Project> projects =
                adminApiService.getProjectsOfAdmin("testAdminFull@example.com");
        List<Project> l = IterableToList(projects);
        assertEquals(1, l.size());
        Project p = l.getFirst();
        assertEquals(p.getProjectName(), "sampleProjectAdminApiService");
    }

    @Test
    void getPendingProjectsEmpty() {
        assertEquals(0, IterableToList(this.adminApiService.getPendingProjects()).size());
    }

    @Test
    void getPendingProjectsNotEmpty() {
        this.projectService.addNewProject(
                new Project(
                        "PendingProjectAdminApiService1", null, LocalDate.now(), PENDING, null));
        this.projectService.addNewProject(
                new Project(
                        "PendingProjectAdminApiService2", null, LocalDate.now(), PENDING, null));
        Iterable<Project> pendingProjects = this.adminApiService.getPendingProjects();
        List<Project> pendingProjectsList = IterableToList(pendingProjects);
        assertEquals(2, pendingProjectsList.size());
        assertTrue(
                List.of("PendingProjectAdminApiService1", "PendingProjectAdminApiService2")
                        .contains(pendingProjectsList.getFirst().getProjectName()));
        assertTrue(
                List.of("PendingProjectAdminApiService1", "PendingProjectAdminApiService2")
                        .contains(pendingProjectsList.getLast().getProjectName()));
    }

    @Test
    void validateInexistantProject() {
        ProjectDecision d = new ProjectDecision(-1, 0, 1);
        assertThrows(ResponseStatusException.class, () -> this.adminApiService.validateProject(d));
    }

    @Test
    void validateExistantProject() {
        Project p =
                new Project("PendingProjectAdminApiService2", null, LocalDate.now(), PENDING, null);
        this.projectService.addNewProject(p);
        assertEquals(PENDING, p.getProjectStatus());
        ProjectDecision d = new ProjectDecision(p.getIdProject(), administratorid, 1);
        this.adminApiService.validateProject(d);
        assertEquals(ACTIVE, p.getProjectStatus());

        // Check if the project was really updated in the database
        assertEquals(0, IterableToList(this.adminApiService.getPendingProjects()).size());
    }

    @Test
    void refuseExistantProject() {
        Project p =
                new Project("PendingProjectAdminApiService2", null, LocalDate.now(), PENDING, null);
        this.projectService.addNewProject(p);
        assertEquals(PENDING, p.getProjectStatus());
        ProjectDecision d = new ProjectDecision(p.getIdProject(), administratorid, 0);
        this.adminApiService.validateProject(d);
        assertEquals(REJECTED, p.getProjectStatus());

        // Check if the project was really updated in the database
        assertEquals(0, IterableToList(this.adminApiService.getPendingProjects()).size());
    }

    @Test
    void addProject() {
        assertEquals(0, IterableToList(this.adminApiService.getPendingProjects()).size());
        Project p1 =
                new Project("PendingProjectAdminApiService2", null, LocalDate.now(), PENDING, null);
        this.adminApiService.addNewProject(p1);

        assertEquals(1, IterableToList(this.adminApiService.getPendingProjects()).size());
    }

    @Test
    void addProjectToAdmin() {
        assertEquals(0, administrator.getListProject().size());
        Project p1 = new Project("assProjectToAdmin", null, LocalDate.now(), ACTIVE, administrator);
        this.adminApiService.addNewProject(p1);
        assertEquals(1, administrator.getListProject().size());
    }

    @Test
    void addProjectToUser() {
        assertNull(entrepreneur.getProjectParticipation());
        Project p1 =
                new Project("assProjectToAdmin", null, LocalDate.now(), ACTIVE, null, entrepreneur);
        this.adminApiService.addNewProject(p1);
        assertEquals(p1, entrepreneur.getProjectParticipation());
    }

    @Test
    void addProjectWithManyUsers() {
        Entrepreneur e1 = new Entrepreneur();
        Entrepreneur e2 = new Entrepreneur();
        Entrepreneur e3 = new Entrepreneur();
        assertNull(e1.getProjectParticipation());
        assertNull(e2.getProjectParticipation());
        assertNull(e3.getProjectParticipation());
        Project p1 = new Project("assProjectToAdmin", null, LocalDate.now(), ACTIVE, null, null);
        p1.updateListEntrepreneurParticipation(e1);
        p1.updateListEntrepreneurParticipation(e2);
        p1.updateListEntrepreneurParticipation(e3);
        this.adminApiService.addNewProject(p1);
        assertEquals(p1, e1.getProjectParticipation());
        assertEquals(p1, e2.getProjectParticipation());
        assertEquals(p1, e3.getProjectParticipation());
    }

    @Test
    void addDuplicateProject() {
        Project p1 =
                new Project("PendingProjectAdminApiService2", null, LocalDate.now(), PENDING, null);
        Project p2 =
                new Project("PendingProjectAdminApiService2", null, LocalDate.now(), PENDING, null);
        this.adminApiService.addNewProject(p1);
        assertThrows(ResponseStatusException.class, () -> this.adminApiService.addNewProject(p2));
    }
}