Clyde/backend/src/test/java/ovh/herisson/Clyde/Endpoints/UserControllerTest.java

package ovh.herisson.Clyde.Endpoints;

import com.github.dockerjava.api.model.ExposedPort;
import com.github.dockerjava.api.model.HostConfig;
import com.github.dockerjava.api.model.PortBinding;
import com.github.dockerjava.api.model.Ports;
import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import org.junit.Assert;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.server.LocalServerPort;
import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
import org.springframework.http.HttpStatus;
import org.springframework.http.HttpStatusCode;
import org.springframework.test.context.ActiveProfiles;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import ovh.herisson.Clyde.ClydeApplication;
import ovh.herisson.Clyde.Repositories.TokenRepository;
import ovh.herisson.Clyde.Repositories.UserRepository;
import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
import ovh.herisson.Clyde.Services.TokenService;
import ovh.herisson.Clyde.Tables.Role;
import ovh.herisson.Clyde.Tables.Token;
import ovh.herisson.Clyde.Tables.User;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import static io.restassured.RestAssured.with;
import static org.hamcrest.Matchers.equalTo;

@Testcontainers
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles(value = "dev")
public class UserControllerTest {
    @LocalServerPort
    private Integer port;

    @Autowired
    private ClydeApplication controller;

    @Autowired
    private TokenService tokenService;

    @Autowired
    private UserRepository userRepository;
    @Autowired
    private TokenRepository tokenRepository;
    @Container
    @ServiceConnection
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:alpine")
            .withDatabaseName("clyde")
            .withUsername("devel")
            .withPassword("devel")
            .withCreateContainerCmdModifier(cmd -> cmd.withHostConfig(new HostConfig().withPortBindings(new PortBinding(Ports.Binding.bindPort(5442), new ExposedPort(5432)))));

    @BeforeAll
    static void beforeAll(){
        postgres.start();
    }

    @AfterAll
    static void afterAll(){
        postgres.stop();
    }

    @BeforeEach
    void setup(){
        RestAssured.baseURI = "http://localhost:" + port;
    }

    @AfterEach
    void aftereach(){
        tokenRepository.deleteAll();
        userRepository.deleteAll();
    }
    @Test
    //Verifie qu'un user qui n'a pas les permissions admin ou secretaire ne peut pas post
    public void userPostTest(){
        User god = new User("god","god","admin@admin.com","everywhere","every",new Date(0), null, Role.Admin,"goddoesntneedpassword");
        Token godToken = new Token(god, tokenService.generateNewToken(), new Date());
        userRepository.save(god);
        tokenService.saveToken(godToken);

        //Can god post herobrine himself ?
        User herobrine = new User("brine","hero","herobrine@student.com","in your WalLs","ShadowsLand",new Date(0), null,Role.Student,"test");

        with().body(herobrine).contentType(ContentType.JSON).header("Authorization", godToken.getToken()).when().request("POST", "/user").then().statusCode(201);

        userRepository.delete(herobrine);

        //Can noob post herobrine without authorizations (no)
        User noob = new User("boon","noob","noob@student.com","everywhere","every",new Date(0), null, Role.Student,"noob");
        Token noobToken = new Token(noob, tokenService.generateNewToken(), new Date());
        userRepository.save(noob);
        tokenService.saveToken(noobToken);

        with().body(herobrine).contentType(ContentType.JSON).header("Authorization", noobToken.getToken()).when().request("POST", "/user").then().statusCode(401);
    }

    @Test
    public void userGetTest(){
        User herobrine = new User("brine","hero","herobrine@student.com","in your WalLs","ShadowsLand",new Date(0), null,Role.Student,"test");
        userRepository.save(herobrine);

        Token t = new Token(herobrine, tokenService.generateNewToken(), new Date());
        tokenRepository.save(t);


        with().header("Authorization", t.getToken()).when().request("GET", "/user").then().assertThat().statusCode(200).body("firstName",equalTo("hero"));
    }

    @Test
    public void userPatchTest(){
        User herobrine = new User("brine","hero","herobrine@admin.com","in your WalLs","ShadowsLand",new Date(0), null,Role.Admin,"test");
        userRepository.save(herobrine);

        Token t = new Token(herobrine, tokenService.generateNewToken(), new Date());
        tokenRepository.save(t);

        Map<String, Object> data = new HashMap<String, Object>();
        data.put("firstName", "test");

        //Teste que le patch s'execute bien
        with().body(data).contentType(ContentType.JSON).header("Authorization", t.getToken()).pathParam("id", herobrine.getRegNo()).when().request("PATCH", "/user/{id}").then().statusCode(200);

        //Teste que la donnée a bien été altérée
        with().header("Authorization", t.getToken()).when().request("GET", "/user").then().body("firstName",equalTo("test"));
    }

    @Test
    public void UserDeleteTest(){
        User god = new User("god","god","admin@admin.com","everywhere","every",new Date(0), null, Role.Admin,"goddoesntneedpassword");
        Token godToken = new Token(god, tokenService.generateNewToken(), new Date());
        userRepository.save(god);
        tokenService.saveToken(godToken);

        User herobrine = new User("brine","hero","herobrine@admin.com","in your WalLs","ShadowsLand",new Date(0), null,Role.Student,"test");
        userRepository.save(herobrine);

        with().header("Authorization", godToken.getToken()).pathParam("id", herobrine.getRegNo()).when().request("DELETE", "/user/{id}").then().statusCode(200);
        Assert.assertEquals(userRepository.existsById(herobrine.getRegNo()), false);
    }
}