backend/src/test/java/ru/diplom/vision/InspectionApplicationTests.java - master - Sturon/Diplom

backend/src/test/java/ru/diplom/vision/InspectionApplicationTests.java
159 строк6 KB
Sturon
Initial
03 июн 2026, 15:01
03 июн 2026, 15:0117b44a2
package ru.diplom.vision;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import javax.imageio.ImageIO;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.web.servlet.MockMvc;
import ru.diplom.vision.domain.CameraSource;
import ru.diplom.vision.domain.CameraSourceType;
import ru.diplom.vision.repository.CameraSourceRepository;
import ru.diplom.vision.repository.InspectionProfileRepository;

@SpringBootTest(properties = {
        "spring.datasource.url=jdbc:h2:mem:inspection-test;MODE=PostgreSQL;DB_CLOSE_DELAY=-1",
        "spring.jpa.hibernate.ddl-auto=create-drop",
        "storage.root=target/test-storage"
})
@AutoConfigureMockMvc
class InspectionApplicationTests {

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private InspectionProfileRepository inspectionProfileRepository;

    @Autowired
    private CameraSourceRepository cameraSourceRepository;

    @Test
    void profilesEndpointReturnsOk() throws Exception {
        mockMvc.perform(get("/api/profiles"))
                .andExpect(status().isOk());
    }

    @Test
    void localInspectionEndpointReturnsBooleanResult() throws Exception {
        Long profileId = inspectionProfileRepository.findAll().stream()
                .findFirst()
                .orElseThrow()
                .getId();

        mockMvc.perform(post("/api/local-inspections/evaluate")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("""
                                {
                                  "profileId": %d,
                                  "minConfidence": 0.0,
                                  "maxDefects": 0
                                }
                                """.formatted(profileId)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.result").isBoolean());
    }

    @Test
    void runProfileEnablesContinuousAnalyzer() throws Exception {
        var profile = inspectionProfileRepository.findAll().stream()
                .findFirst()
                .orElseThrow();

        mockMvc.perform(post("/api/profiles/{id}/run", profile.getId()))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.analysisEnabled").value(true));

        mockMvc.perform(post("/api/profiles/{id}/stop", profile.getId()))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.analysisEnabled").value(false));
    }

    @Test
    void camerasEndpointReturnsOnlyActiveCameras() throws Exception {
        CameraSource inactiveCamera = new CameraSource();
        inactiveCamera.setName("Inactive test camera");
        inactiveCamera.setType(CameraSourceType.MOCK_REFERENCE);
        inactiveCamera.setActive(false);
        cameraSourceRepository.save(inactiveCamera);

        mockMvc.perform(get("/api/cameras"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$[?(@.name == 'Inactive test camera')]").isEmpty());
    }

    @Test
    void externalInspectionEndpointImportsDesktopAnalyzerResult() throws Exception {
        Long profileId = inspectionProfileRepository.findAll().stream()
                .findFirst()
                .orElseThrow()
                .getId();

        mockMvc.perform(post("/api/profiles/{id}/run", profileId))
                .andExpect(status().isOk());

        MockMultipartFile result = new MockMultipartFile(
                "result",
                "result.json",
                MediaType.APPLICATION_JSON_VALUE,
                """
                        {
                          "profileId": %d,
                          "result": false,
                          "defectCount": 1,
                          "processingTimeMs": 12,
                          "summary": "Desktop analyzer test result",
                          "defects": [
                            {
                              "defectType": "too-dark",
                              "roiName": "Корпус",
                              "roiOrder": 0,
                              "confidence": 0.8,
                              "x": 1,
                              "y": 1,
                              "width": 10,
                              "height": 10,
                              "notes": "test"
                            }
                          ]
                        }
                        """.formatted(profileId).getBytes()
        );
        MockMultipartFile image = new MockMultipartFile(
                "image",
                "frame.png",
                MediaType.IMAGE_PNG_VALUE,
                testPng()
        );

        mockMvc.perform(multipart("/api/external-inspections")
                        .file(result)
                        .file(image))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.status").value("DEFECT"))
                .andExpect(jsonPath("$.defectCount").value(1));
    }

    private byte[] testPng() throws Exception {
        BufferedImage image = new BufferedImage(32, 32, BufferedImage.TYPE_INT_RGB);
        var graphics = image.createGraphics();
        graphics.setColor(Color.BLACK);
        graphics.fillRect(0, 0, 32, 32);
        graphics.dispose();

        ByteArrayOutputStream output = new ByteArrayOutputStream();
        ImageIO.write(image, "png", output);
        return output.toByteArray();
    }
}