Как протестировать метод поиска?

Question

Я написал тест в котором пытаюсь сравнить результат поиска (result) и созданный объект для сравнения (expResult). Assert.assertEquals(expResult, result) не даст true так как в объекте result четыре объекта-результат поиска, а в expResult один...

С чем сравнивать result чтобы тест корректно сработал?

Вот мой тест метод:

@Test
@Transactional
public void testFilter2() {
    System.out.println("filter");

    FileFilterDto fileFilterDto = new FileFilterDto();
    LocalDate beginDate = LocalDate.parse("2020-02-20");
    LocalDate endDateCreate = LocalDate.parse("2021-12-31");
    String uuidFile = "00000000-0000-0000-0000-000000000000";
    String uuidFile1 = "00000000-0000-0000-0000-000000000000";

    Paginating paginating = new Paginating();

    fileFilterDto.setIdOwner(UUID.fromString(uuidFile1));
    fileFilterDto.setExt("pdf");
    fileFilterDto.setDeleted(false);
    paginating.setNumber(0);
    paginating.setSize(10);
    fileFilterDto.setPaginating(paginating);
    fileFilterDto.setBeginDateCreate(beginDate);
    fileFilterDto.setEndDateCreate(endDateCreate);

    FileServiceImpl instance = new FileServiceImpl(dbFileService, 
  minioService, objectMapper);
    instance.setBucketName(bucketName);

    FileResponse expResult = new FileResponse();
    LocalDateTime dateFile = LocalDateTime.now();
    OwnerDto ownerDto = new OwnerDto();

    FileObjDTO fileObjDTO = new FileObjDTO();
    ownerDto.setUuid(UUID.fromString(uuidFile));
    ownerDto.setName("TestK");
    fileObjDTO.setUuidFile(UUID.fromString(uuidFile));
    fileObjDTO.setUpdateDateTime(dateFile);
    fileObjDTO.setCreateDateTime(dateFile);
    fileObjDTO.setFileName("testFileName");
    fileObjDTO.setExt("pdf");
    fileObjDTO.setOwnerDto(ownerDto);
    fileObjDTO.setDeleted(false);
    fileObjDTO.setFileData("{\"j\":\"10\"}");
    fileObjDTO.setFolder(folderData);

    expResult.setMessage("");
    expResult.setSuccess(true);
    PagerDTO pagerDTO = new PagerDTO();
    expResult.setPagerDTO(pagerDTO);
    expResult.getPagerDTO().setPrev(false);
    expResult.getPagerDTO().setNext(false);
    expResult.getPagerDTO().setTotal(6);
    expResult.getPagerDTO().setSize(10);
    expResult.getFileObjPages().add(fileObjDTO);


    instance.getInputStreamForFileObjDto(fileObjDTO);
    instance.create(fileObjDTO);
    FileResponse result = instance.filter(fileFilterDto);

    LocalDate localDate1 = dateFile.toLocalDate();
    if (localDate1.isBefore(beginDate) == false && localDate1.isAfter(endDateCreate) == false)
        System.out.println("yes");


    Assert.assertEquals(fileFilterDto.getIdOwner(), fileObjDTO.getUuidFile());
    Assert.assertEquals(fileFilterDto.getExt(), fileObjDTO.getExt());
    Assert.assertEquals(expResult, result);
    Assert.assertNotNull(result);
}

FileServiceImpl:

@Service
@RequiredArgsConstructor
public class FileServiceImpl implements FileService {

@Value("${minio.bucket.name}")
@Getter
@Setter
private String bucketName;
private final DbFileService dbFileService;
private final MinioService minioService;
private final ObjectMapper objectMapper;

@Transactional
@Override
public FileResponse create(FileObjDTO fileObjDTO) {
    FileObj fileObj = dbFileService.create(fileObjDTO);
    minioService.putObjectIntoTheBucket(bucketName, 
            getInputStreamForFileObjDto(fileObjDTO), 
            fileObj.getId().toString());
    fileObjDTO = objectMapper.fileToFileObjDTO(fileObj);
    FileResponse fileResponse = new FileResponse();
    fileResponse.setMessage("");
    fileResponse.setSuccess(true);
    fileResponse.getFileObjPages().add(fileObjDTO);
    return fileResponse;
}

//получение ИнпутСтрима для минио.

public InputStream getInputStreamForFileObjDto(FileObjDTO fileObjDTO) {
    return new ByteArrayInputStream(Optional.of(fileObjDTO
            .getFileData()
            .getBytes())
            .orElseThrow());
}



@Transactional(readOnly = true)
@Override
public FileResponse filter(FileFilterDto fileFilterDto) {
    return dbFileService.filter(fileFilterDto);
}

@Transactional
@Override
public FileResponse update(UUID uuid, FileObjDTO fileObjDTO) {
   FileObj fileObj = dbFileService.update(uuid, fileObjDTO);
    if (fileObjDTO.getFileData() != null) {
        minioService.putObjectIntoTheBucket(bucketName,
                getInputStreamForFileObjDto(fileObjDTO),
                uuid.toString());
    }
    fileObjDTO = objectMapper.fileToFileObjDTO(fileObj);
    fileObjDTO.setFileData(null);
    FileResponse fileResponse = new FileResponse();
    fileResponse.setMessage("");
    fileResponse.setSuccess(true);
    fileResponse.getFileObjPages().add(fileObjDTO);
    return fileResponse;
}

@Transactional
@Override
public FileResponse setDeletedStatusForFileByUuid(UUID uuid) {
    return dbFileService.deleted(uuid);
}

@Transactional(readOnly = true)
@Override
public FileResponse getFileByUuid(UUID uuid) {
    FileObjDTO fileObjDTO = dbFileService.getFileById(uuid);
   byte[] file = minioService.getObjectFromBucket(bucketName, 
 uuid.toString());
    fileObjDTO.setFileData(convertArrayByteToString(file));
    FileResponse fileResponse = new FileResponse();
    fileResponse.setMessage("");
    fileResponse.setSuccess(true);
    fileResponse.getFileObjPages().add(fileObjDTO);
    return fileResponse;
}

/**перевод массива байта в стрингу для минио.
 */
protected String convertArrayByteToString(byte[] arr) {
    StringBuffer str = new StringBuffer();
    for (int i = 0; i < arr.length; i++) {
        str.append((char) arr[i]);
    }
    return new String(str);
}
  }

DbFileServiceImpl:

@Service
@RequiredArgsConstructor
public class DbFileServiceImpl implements DbFileService {

private final EntityManager em;
private final FileRepository fileRepository;
private final FileFilterRepository fileFilterRepository;
private final OwnerRepository ownerRepository;
private final FolderDataRepository folderDataRepository;

@Autowired
private final ObjectMapper objectMapper;
private static final String UNDEFINED_OWNER_NAME = "notNameOwner";
private static final UUID UNDEFINED_OWNER_UUID = 
UUID.fromString("00000000-0000-0000-0000-000000000000");
private static final LocalDateTime DEFAULT_DATE = LocalDateTime.of(2000, 
1, 1, 0, 0, 0);
private static final LocalDateTime DEFAULT_END_DATE = 
LocalDateTime.now().plusDays(1L);

@Override
public FileObj create(FileObjDTO fileObjDTO) {
    //fileObjDTO.setFolder("12-02-2021");
    FileObj fileObj = objectMapper.fileToFileObj(fileObjDTO);


    fileObj.setCreateDateTime(Optional.ofNullable(fileObjDTO.getCreateDateTime()).orElse(LocalDateTime.now()));
    if (fileObj.getCreateDateTime().isAfter(LocalDateTime.now())) throw new RuntimeException("Invalid date");
    if (fileObj.getCreateDateTime().isBefore(DEFAULT_DATE.minusYears(10))) throw new RuntimeException("Incorrect date");

    fileObj.setUpdateDateTime(Optional.ofNullable(fileObjDTO.getUpdateDateTime()).orElse(LocalDateTime.now()));

    if (fileObjDTO.getOwnerDto() == null) {
        fileObjDTO.setOwnerDto(new OwnerDto());
    }

    UUID uuidOwner = 
 Optional.ofNullable(fileObjDTO.getOwnerDto().getUuid())
.orElse(UNDEFINED_OWNER_UUID);
    String ownerName = Optional.ofNullable(fileObjDTO.getOwnerDto().getName()).orElse(UNDEFINED_OWNER_NAME);
    Owner owner = ownerRepository.findById(uuidOwner).orElseGet(() -> ownerRepository.save(new Owner(uuidOwner, ownerName)));
    fileObj.setOwner(owner);

    MinioServiceImpl ms = new MinioServiceImpl();
    FolderData folderData = new FolderData();

     ms.getFolderData());

        folderData.setFolderData(ms.getFolderData());

        FolderData f = 
folderDataRepository.findByName(folderData.getFolderData());

        if (f == null) {
            FolderData folderData1 = 
folderDataRepository.save(folderData);
            fileObj.setFolderData(folderData1);
            fileRepository.save(fileObj);



        }else {
            fileObj.setFolderData(f);
            fileRepository.save(fileObj);
        }



    fileObj.setFileData(null);
    return fileObj;
 }

  @Override
   public FileResponse filter(FileFilterDto fileFilterDto) {

    FileResponse fileResponse = new FileResponse();
    PagerDTO pagerDTO = new PagerDTO();

    Paginating paginating = fileFilterDto.getPaginating();

    Pageable pageable = PageRequest.of(paginating.getNumber(), 
   paginating.getSize());

    if (fileFilterDto.getBeginDateCreate() == null) {
        fileFilterDto.setBeginDateCreate(DEFAULT_DATE.toLocalDate());
    }
    if (fileFilterDto.getEndDateCreate() == null) {
        fileFilterDto.setEndDateCreate(DEFAULT_END_DATE.toLocalDate());
    }

    //flag for native filter
    boolean checkDeleted = false;
    boolean checkExt = false;
    boolean checkOwnerId = false;
   //fields for native filter
    boolean deleted = false;
  LocalDateTimebeginDateTime =
  LocalDateTime.of(fileFilterDto.getBeginDateCreate(), LocalTime.MIN);
    LocalDateTime endDateTime = 
  LocalDateTime.of(fileFilterDto.getEndDateCreate(), 
  LocalTime.MAX.truncatedTo(ChronoUnit.SECONDS));
    String ext = "";
    UUID ownerUuid = UUID.randomUUID();

    if (fileFilterDto.getDeleted() != null) {
        deleted = fileFilterDto.getDeleted();
    }
    if (fileFilterDto.getIdOwner() != null) {
        ownerUuid = fileFilterDto.getIdOwner();
    }
    if (fileFilterDto.getExt() != null) {
        ext = fileFilterDto.getExt();
    }

    if (fileFilterDto.getDeleted() != null) checkDeleted = true;
    if (fileFilterDto.getExt() != null) checkExt = true;
    if (fileFilterDto.getIdOwner() != null) checkOwnerId = true;

    Page<FileObj> pageFilesObj = 
fileFilterRepository.findByFilter(checkDeleted, deleted, checkExt, ext, 
checkOwnerId, ownerUuid, beginDateTime, endDateTime, pageable);

    List<FileObjDTO> fileObjDTOList = 

pageFilesObj.getContent().stream().map(objectMapper::fileToFileObjDTO)
.collect(Collectors.toList());

    fileResponse.setPagerDTO(pagerDTO);
    fileResponse.getPagerDTO().setNext(pageFilesObj.hasNext());
    fileResponse.getPagerDTO().setPrev(pageFilesObj.hasPrevious());
    fileResponse.getPagerDTO().setSize(pageFilesObj.getSize());
    fileResponse.getPagerDTO().setTotal(pageFilesObj.getTotalElements());

    fileResponse.setFileObjPages(fileObjDTOList);

    fileResponse.setMessage("");
    fileResponse.setSuccess(true);

    return fileResponse;
}

@Override
public FileObj update(UUID uuid, FileObjDTO fileObjDTO) {
    //проверить при несущ
    FileObj fileObjToUpdate = fileRepository.getOne(uuid);

    if (fileObjDTO.getFileData() != null) {
        fileObjToUpdate.setFileData(fileObjDTO.getFileData());
    }
    if (fileObjDTO.getFileName() != null) {
        fileObjToUpdate.setFileName(fileObjDTO.getFileName());
    }
    if (fileObjDTO.getExt() != null) {
        fileObjToUpdate.setExt(fileObjDTO.getExt());
    }
    if (fileObjDTO.getDeleted() != null) {
        fileObjToUpdate.setDeleted(fileObjDTO.getDeleted());
    }
    if (fileObjDTO.getOwnerDto() != null) {
        Owner owner = objectMapper.ownerToOwner(fileObjDTO.getOwnerDto());
        fileObjToUpdate.setOwner(owner);
    }

    fileObjToUpdate.setUpdateDateTime(LocalDateTime.now());
    fileRepository.save(fileObjToUpdate);
    return fileObjToUpdate;
}

@Override
public FileResponse deleted(UUID uuid) {
    FileResponse fileResponse = new FileResponse();
    FileObj fileObj = em.getReference(FileObj.class, uuid);
    if (!fileObj.isDeleted()) {
        fileObj.setUpdateDateTime(LocalDateTime.now());
        fileObj.setDeleted(true);
        fileRepository.save(fileObj);
        fileResponse.setMessage("");
    } else {
        fileResponse.setMessage("Файл уже помечен на удаление");
    }
    fileResponse.setSuccess(true);
    fileResponse.setFileObjPages(null);
    return fileResponse;
}
@Override
public FileObjDTO getFileById(UUID uuid) {
    Optional<FileObj> fileObj = fileRepository.findById(uuid);
    FileObjDTO fileObjDTO =
objectMapper.fileToFileObjDTO(fileObj.orElseThrow(() -> new 
NoSuchElementInMinioException("No such element")));
    OwnerDto ownerDto = 
objectMapper.ownerToOwnerDto(fileObj.get().getOwner());
    fileObjDTO.setOwnerDto(ownerDto);
    return fileObjDTO;
}

   public static Specification<FileObj> ownerFetch() {
    return ((root, criteriaQuery, criteriaBuilder) -> {
        root.fetch("owner", JoinType.LEFT);
        root.get("owner").get("id");
        return null;
    });
}
}

БЛОГ НА HUSL

Как протестировать метод поиска?

Ответы (0 шт):