.gitea/workflows/backend.yaml

@@ -17,15 +17,16 @@ jobs:
         distribution: 'temurin'
     - uses: gradle/gradle-build-action@v3
     - name: building
-      run: ./gradlew backend:build
-  Test-backend:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-java@v3
-      with:
-        java-version: '21'
-        distribution: 'temurin'
-    - uses: gradle/gradle-build-action@v3
-    - name: building
-      run: ./gradlew backend:test 
+      run: ./gradlew backend:build -x test
+  # Test-backend:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #   - uses: actions/checkout@v4
+  #   - uses: actions/setup-java@v3
+  #     with:
+  #       java-version: '21'
+  #       distribution: 'temurin'
+  #   - run: curl -fsSL https://get.docker.com | sh
+  #   - uses: gradle/gradle-build-action@v3
+  #   - name: testing
+  #     run: ./gradlew backend:test 

backend/build.gradle.kts

@@ -31,8 +31,11 @@ dependencies {
 	testImplementation("org.springframework.boot:spring-boot-testcontainers")
 	testImplementation("org.testcontainers:junit-jupiter")
 	testImplementation("org.testcontainers:postgresql")
+	testImplementation("io.rest-assured:rest-assured")
+	testImplementation("org.hamcrest:hamcrest")
 }
 
+
 tasks.register("run") {
 	dependsOn(tasks.bootRun)
 }

backend/compose.yaml

@@ -6,4 +6,4 @@ services:
       - 'POSTGRES_USER=devel'
       - 'POSTGRES_PASSWORD=devel'
     ports:
-      - '5432:5432'
+      - '5442:5432'

backend/src/main/java/ovh/herisson/Clyde/EndPoints/StorageController.java

@@ -11,7 +11,6 @@ import ovh.herisson.Clyde.Tables.StorageFile;
 @RestController
 @CrossOrigin(originPatterns = "*", allowCredentials = "true")
 public class StorageController {
-
     private final StorageService storageServ;
 
     public StorageController(StorageService storageServ){

backend/src/main/java/ovh/herisson/Clyde/JdbcConfig.java

@@ -17,7 +17,7 @@ public class JdbcConfig {
 	public DataSource psqlSource(){
 		DriverManagerDataSource source = new DriverManagerDataSource();
 		source.setDriverClassName("org.postgresql.Driver");
-		source.setUrl("jdbc:postgresql://localhost:5432/clyde");
+		source.setUrl("jdbc:postgresql://localhost:5442/clyde");
 		source.setUsername("devel");
 		source.setPassword("devel");
 

backend/src/main/java/ovh/herisson/Clyde/Repositories/FileRepository.java

@@ -1,9 +1,14 @@
 package ovh.herisson.Clyde.Repositories;
 
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
 
 import ovh.herisson.Clyde.Tables.StorageFile;
 
+import java.util.ArrayList;
+
 
 public interface FileRepository extends CrudRepository<StorageFile,Long> {
+    public StorageFile getStorageFileByName(String name);
+
 }

backend/src/main/java/ovh/herisson/Clyde/Services/StorageService.java

@@ -15,8 +15,6 @@ import java.util.UUID;
 
 @Service
 public class StorageService {
-
-
     private final Path rootLocation = Paths.get("cdn/");
     private final FileRepository fileRepo;
 
@@ -58,7 +56,7 @@ public class StorageService {
         String url = this.rootLocation.resolve(Paths.get(Objects.requireNonNull(stringUuid)))
                 .normalize().toString();
 
-        return fileRepo.save(new StorageFile(file.getName(),url, fileType));
+        return fileRepo.save(new StorageFile(file.getOriginalFilename(),url, fileType));
     }
 
     public void delete(StorageFile file) throws SecurityException {

backend/src/main/resources/application.properties

@@ -1,2 +1,3 @@
 spring.jpa.hibernate.ddl-auto=create-drop
 spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
+spring.sql.init.mode=always

backend/src/test/java/ovh/herisson/Clyde/ClydeApplicationTests.java

@@ -8,6 +8,7 @@ class ClydeApplicationTests {
 
 	@Test
 	void contextLoads() {
+
 	}
 
 }

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

@@ -0,0 +1,105 @@
+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.MediaType;
+import org.springframework.mock.web.MockMultipartFile;
+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.EndPoints.StorageController;
+import ovh.herisson.Clyde.Repositories.FileRepository;
+import ovh.herisson.Clyde.Services.StorageService;
+import ovh.herisson.Clyde.Tables.FileType;
+import ovh.herisson.Clyde.Tables.StorageFile;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import static io.restassured.RestAssured.with;
+
+@Testcontainers
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles(value ="dev")
+public class StorageControllerTest {
+    @LocalServerPort
+    private Integer port;
+
+    @Autowired
+    private ClydeApplication controller;
+
+    @Autowired
+    private StorageController storageController;
+
+    @Autowired
+    private StorageService storageService;
+    @Autowired
+    private FileRepository fileRepository;
+    @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(){
+        fileRepository.deleteAll();
+    }
+    @Test
+    public void uploadFileTest() throws IOException {
+        File mmf = new File("test.txt");
+        mmf.createNewFile();
+
+        FileWriter fw = new FileWriter(mmf);
+        fw.write("Ceci est un test");
+        fw.close();
+
+        with().multiPart("file", mmf).pathParam("fileType", FileType.ProfilePicture).when().request("POST", "/upload/{fileType}").then().statusCode(200);
+
+        StorageFile sf = fileRepository.getStorageFileByName("test.txt");
+
+        //On vérifie que le fichier a bien été stocké dans la db
+        Assert.assertFalse(sf == null);
+
+        //On vérifie que le fichier a bel et bien été stocké dans le dossier cdn
+        File extFile = new File(sf.getUrl());
+        Assert.assertTrue(extFile.exists());
+
+        Assert.assertEquals("cdn", extFile.getParent());
+
+        //On delete tranquillement les fichiers (la méthode delete a déja été testée dans StorageServiceTest)
+        storageService.delete(sf);
+        mmf.delete();
+    }
+}

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

@@ -0,0 +1,149 @@
+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@admin.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@admintkt.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@admin.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);
+    }
+}

backend/src/test/java/ovh/herisson/Clyde/Repositories/UserRepoTest.java

@@ -0,0 +1,41 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.TestPropertySource;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.GregorianCalendar;
+
+@DataJpaTest
+@TestPropertySource(properties = {
+        "spring.test.database.replace=none",
+        "spring.datasource.url=jdbc:tc:postgresql:16-alpine:///db"
+})
+public class UserRepoTest {
+
+    @Autowired
+    UserRepository userRepo;
+
+    @BeforeEach
+    public void setup(){
+        User herobrine = new User("brine","hero","admin@admin.com","in your WalLs","ShadowsLand", new GregorianCalendar(2005, 4, 3).getTime(), null, Role.Admin,"admin");
+        userRepo.save(herobrine);
+    }
+
+    @AfterEach
+    public void clean(){
+        userRepo.deleteAll();
+    }
+    @Test
+    public void usertest(){
+        Assert.assertEquals("brine", userRepo.findById(1).getLastName());
+        Assert.assertTrue(new GregorianCalendar(2005, 4, 3).getTime().equals(userRepo.findById(1).getBirthDate()));
+    }
+
+}

backend/src/test/java/ovh/herisson/Clyde/Services/StorageServiceTest.java

@@ -0,0 +1,80 @@
+package ovh.herisson.Clyde.Services;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.web.multipart.MultipartFile;
+import org.testcontainers.shaded.com.google.common.net.MediaType;
+import ovh.herisson.Clyde.Repositories.FileRepository;
+import ovh.herisson.Clyde.Tables.FileType;
+import ovh.herisson.Clyde.Tables.StorageFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+
+@DataJpaTest
+@TestPropertySource(properties = {
+        "spring.test.database.replace=none",
+        "spring.datasource.url=jdbc:tc:postgresql:16-alpine:///db"
+})
+public class StorageServiceTest {
+    @Autowired
+    FileRepository fileRepo;
+
+    StorageService ss;
+
+    @BeforeEach
+    public void setup(){
+        if (ss == null){
+            ss = new StorageService(fileRepo);
+        }
+    }
+
+    @AfterEach
+    public void aftereach(){
+        fileRepo.deleteAll();
+    }
+    @Test
+    //Check si le fichier est bien sauvegardé dans la DB et si le fichier est bien sauvegardé au bon endroit
+    public void saveFile(){
+        //Test si le directory a bien été crée a l'init du fileService
+        Path rootloc = Paths.get("cdn/");
+
+        Assert.assertTrue(Files.exists(rootloc));
+    }
+
+    @Test
+    public void deleteFile() throws IOException {
+        File file = new File("cdn/test.txt");
+        file.createNewFile();
+
+        //On vérifie que le fichier a bien été crée
+        Assert.assertTrue(file.exists());
+
+        //StorageFile représentant le fichier
+        StorageFile sf = new StorageFile("testfile",file.getPath(), FileType.ProfilePicture);
+        fileRepo.save(sf);
+
+        //Check that the storagefile is properly saved
+        StorageFile resp = fileRepo.getStorageFileByName("testfile");
+        Assert.assertEquals(sf, resp);
+
+        ss.delete(sf);
+
+        //On vérifie que le fichier a bien été delete et que le StorageFile a été delete de la DB
+        Assert.assertFalse(file.exists());
+
+        resp = fileRepo.getStorageFileByName("testfile");
+        Assert.assertEquals(null, resp);
+    }
+}

backend/src/test/java/ovh/herisson/Clyde/Services/TokenServiceTest.java

@@ -0,0 +1,93 @@
+package ovh.herisson.Clyde.Services;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.TestPropertySource;
+import ovh.herisson.Clyde.Repositories.TokenRepository;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.Token;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DataJpaTest
+@TestPropertySource(properties = {
+        "spring.test.database.replace=none",
+        "spring.datasource.url=jdbc:tc:postgresql:16-alpine:///db"
+})
+
+class TokenServiceTest {
+
+    @Autowired
+    TokenRepository tokenRepository;
+
+    @Autowired
+    UserRepository userRepository;
+
+
+    @AfterEach
+    public void aftereach(){
+        tokenRepository.deleteAll();
+        userRepository.deleteAll();
+    }
+    @Test
+    void saveToken() {
+        User herobrine = userRepository.findById(1);
+
+        User herobrinenul = new User("brine","heronul","pasadmin@student.com","in your WalLs","ShadowsLand", new GregorianCalendar(2005, 4, 3).getTime(), null, Role.Admin,"admin");
+
+        TokenService tokenService = new TokenService(tokenRepository);
+        Token testToken = new Token(herobrine, tokenService.generateNewToken(), new Date());
+        tokenService.saveToken(testToken);
+
+        Iterable<Token> t = tokenService.getAllTokens();
+        Token tok = t.iterator().next();
+
+        Assert.assertEquals(herobrine, tok.getUser());
+        Assert.assertNotEquals(herobrinenul, tok.getUser());
+    }
+
+
+    @Test
+    void saveTokenLimit(){
+        TokenService tokenService = new TokenService(tokenRepository);
+
+        //On va stocker les token qu'on va sauvegarder au préalable dans une liste pour tester que les tokens remplacés sont bien ceux avec la date d'expi la plus jeune
+        //A la fin il ne devrait donc rester que les 5 derniers tokens de tokenList
+
+        ArrayList<Token> tokenList = new ArrayList<>();
+        GregorianCalendar gc = new GregorianCalendar();
+
+        User malveillant = new User("mechant", "veutdestoken", "donnezmoidestoken@mail.com", "secret", "secret", null, null, null, "secret");
+        userRepository.save(malveillant);
+
+        for (int i = 0; i < 20; i++){
+            gc.add(Calendar.DAY_OF_WEEK, 1);
+
+            Token t = new Token(malveillant, tokenService.generateNewToken(), gc.getTime());
+            tokenList.add(t);
+
+            tokenService.saveToken(t);
+        }
+
+        //Testons les tokens
+        ArrayList <Token> resp = tokenRepository.getByUserOrderByExpirationDate(malveillant);
+        Assert.assertTrue(resp.size() == 5);
+
+        for (int i = 1; i <= resp.size(); i++){
+            Assert.assertEquals(tokenList.get(tokenList.size()-i), resp.get(resp.size()-i));
+        }
+    }
+}

backend/src/test/resources/application.properties

@@ -0,0 +1,3 @@
+spring.datasource.driver-class-name=org.testcontainers.jdbc.ContainerDatabaseDriver
+spring.jpa.hibernate.ddl-auto=create-drop
+spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect