Nenhum teste foi encontrado no pacote

Segue cód

MedicoRepository

package med.vol.api.domain.medico;

import med.vol.api.domain.consultas.Consulta;
import med.vol.api.domain.endereco.DadosCadastroEndereco;
import med.vol.api.domain.paciente.DadosCadastroPaciente;
import med.vol.api.domain.paciente.Paciente;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import org.springframework.test.context.ActiveProfiles;

import java.time.DayOfWeek;
import java.time.LocalDateTime;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;


@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@ActiveProfiles("test")
class MedicoRepositoryTest {

    @Autowired
    private MedicoRepository medicoRepository;

    @Autowired
    private TestEntityManager em;


    @Test
    @DisplayName("Devolver NULL quando unico médico cadastrado não está disponivel na data")
    void getMedicoRandomFreeOnDateCenario1() {
        //given ou arrange
        var proximaSegundaAs10 = LocalDateTime.now()
                .with(TemporalAdjusters.next(DayOfWeek.MONDAY))
                .withHour(10).withMinute(0);


        //when ou act
        var medico = cadastrarMedico("Medico","medico@voll.med","111111",Especialidade.CARDIOLOGIA);
        var paciente = cadastrarPaciente("Paciente","paciente@voll.med","11122233345");
        cadastrarConsulta(medico,paciente, proximaSegundaAs10);


        var medicoLivre =medicoRepository.getMedicoRandomFreeOnDate(Especialidade.CARDIOLOGIA, proximaSegundaAs10);
        //then ou assert
        assertThat(medicoLivre).isNull();
    }


    @Test
    @DisplayName("Deveria devovler medico quando ele estiver disponivel na data")
    void getMedicoRandomFreeOnDateCenario2() {

        //given ou arrange
        var proximaSegundaAs10 = LocalDateTime.now()
                .with(TemporalAdjusters.next(DayOfWeek.MONDAY))
                .withHour(10).withMinute(0);

        var medico = cadastrarMedico("Medico","medico@voll.med","111111",Especialidade.CARDIOLOGIA);

        //when ou act
        var medicoLivre =medicoRepository.getMedicoRandomFreeOnDate(Especialidade.CARDIOLOGIA, proximaSegundaAs10);

        //then ou assert
        assertThat(medicoLivre).isEqualTo(medico);
    }




    private void cadastrarConsulta(Medico medico, Paciente paciente, LocalDateTime data) {
        em.persist(new Consulta(null, medico, paciente, data, null));
    }

    private Medico cadastrarMedico(String nome, String email, String crm, Especialidade especialidade) {
        var medico = new Medico(dadosMedico(nome, email, crm, especialidade));
        em.persist(medico);
        return medico;
    }

    private Paciente cadastrarPaciente(String nome, String email, String cpf) {
        var paciente = new Paciente(dadosPaciente(nome, email, cpf));
        em.persist(paciente);
        return paciente;
    }

    private DadosCadastroMedico dadosMedico(String nome, String email, String crm, Especialidade especialidade) {
        return new DadosCadastroMedico(
                nome,
                email,
                "61999999999",
                crm,
                especialidade,
                dadosEndereco()
        );
    }

    private DadosCadastroPaciente dadosPaciente(String nome, String email, String cpf) {
        return new DadosCadastroPaciente(
                nome,
                email,
                "61999999999",
                cpf,
                dadosEndereco()
        );
    }

    private DadosCadastroEndereco dadosEndereco() {
        return new DadosCadastroEndereco(
                "rua xpto",
                "bairro",
                "00000000",
                "Brasilia",
                "test",
                "1",
                "2"
        );
    }
}

Segue cód

ConsultaControllerTest

package med.vol.api.controller;

import jakarta.validation.constraints.Future;
import jakarta.validation.constraints.NotNull;
import med.vol.api.domain.consultas.AgendaDeConsultas;
import med.vol.api.domain.consultas.DadosAgendamentoConsulta;
import med.vol.api.domain.consultas.DadosDetalhamentoConsulta;
import med.vol.api.domain.medico.Especialidade;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.json.AutoConfigureJsonTesters;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.autoconfigure.webservices.server.AutoConfigureMockWebServiceClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.json.JacksonTester;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.web.servlet.MockMvc;

import java.time.LocalDateTime;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;

@SpringBootTest
@AutoConfigureMockMvc // Configurar o Mock
@AutoConfigureJsonTesters
class ConsultaControllerTest {

    @Autowired
    private MockMvc mvc; //Pode simular requisições

    @Autowired
    private JacksonTester<DadosAgendamentoConsulta> dadosAgendamentoConsultaJson;

    @Autowired
    private JacksonTester<DadosDetalhamentoConsulta> dadosDetalhamentoConsultaJson;

    @MockBean
    private AgendaDeConsultas agendaDeConsultas;


    @Test
    @DisplayName("Deveria devolver código HTTP 400 quando informações estão invalidas")
    @WithMockUser //Auteticar um usuário dinamico
    void agenda_cenario1() throws Exception {
        var response = mvc.perform(post("/consultas"))
                .andReturn().getResponse();

        assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST.value());
    };


    @Test
    @DisplayName("Deveria devolver código HTTP 200 quando informações estão validas")
    @WithMockUser //Auteticar um usuário dinamico
    void agenda_cenario2() throws Exception {

        Especialidade especialidade = Especialidade.CARDIOLOGIA;
        LocalDateTime data = LocalDateTime.now().plusHours(1);

        var dadosDetalhamento = new DadosDetalhamentoConsulta(null, 2l,5l,data);
        when(agendaDeConsultas.agendar(any())).thenReturn(dadosDetalhamento);

        var response = mvc.perform(post("/consultas")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(dadosAgendamentoConsultaJson.write(
                                new DadosAgendamentoConsulta(2l,5l, data, especialidade)
                        ).getJson()) // Fazer o processo de criação de Json de através da class
                )
                .andReturn().getResponse();

        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());

        var jsonEsperado = dadosDetalhamentoConsultaJson.write(
                dadosDetalhamento
        ).getJson();

        assertThat(response.getContentAsString()).isEqualTo(jsonEsperado);
    };

}