Problem z testami service

org.opentest4j.AssertionFailedError: 
Expected :true
Actual   :false

@Test
void shouldDeleteNoteById_Test() {
    Note note = new Note(1, LocalDate.now(), "testTitle", "testText");

    when(noteRepository.findById(1)).thenReturn(Optional.of(note));

    noteService.deleteById(note.getId());

    assertTrue(noteRepository.findById(note.getId()).isEmpty());

    verify(noteRepository, times(1)).findById(1);
    verify(noteRepository, times(1)).delete(note);

}

@Test
void shouldDeleteAllNotes_Test() {
    List<Note> mockNotes = Arrays.asList(
            new Note(1, LocalDate.now(), "testTitle", "testText"),
            new Note(2, LocalDate.now(), "testTitle11", "testText11")
    );

    when(noteRepository.findAll()).thenReturn(mockNotes);
    doNothing().when(noteRepository).deleteAll();

    noteService.deleteAllNotes();

    verify(noteRepository, times(1)).findAll();
    verify(noteRepository, times(1)).deleteAll();

    List<Note> noteList = noteRepository.findAll();

    assertTrue(noteList.isEmpty());
}

Note note = new Note(1, LocalDate.now(), "testTitle", "testText");
when(noteRepository.findById(1)).thenReturn(Optional.of(note));
noteService.deleteById(note.getId());
assertTrue(noteRepository.findById(note.getId()).isEmpty());

@SpringBootTest
@AutoConfigureMockMvc
public class NoteServiceTest {
    @Mock
    private NoteRepository noteRepository;
    @InjectMocks
    private NoteServiceImpl noteService;

    @Test
    void shouldCreateNote_Test() {
        Note note = new Note(1, LocalDate.now(), "testTitle", "testText");

        when(noteRepository.save(note)).thenReturn(note);

        Note resultNote = noteService.createNote(note);

        assertEquals(note.getId(), resultNote.getId());
        assertEquals("testTitle", resultNote.getTitle());
        assertEquals("testText", resultNote.getText());

        verify(noteRepository, times(1)).save(note);
    }

    @Test
    void shouldFindNoteById_Test() {
        Note note = new Note(1, LocalDate.now(), "testTitle", "testText");

        when(noteRepository.findById(note.getId())).thenReturn(Optional.of(note));

        Note resultNote = noteService.getNoteById(note.getId());

        verify(noteRepository, times(1)).findById(note.getId());

        assertEquals(note, resultNote);
    }

    @Test
    void shouldFindAllNotes_Test() {
        List<Note> mockNotes = Arrays.asList(new Note(1, LocalDate.now(), "testTitle", "testText")
                , new Note(2, LocalDate.now(), "testTitle1", "testText1"));

        when(noteRepository.findAll()).thenReturn(mockNotes);

        List<Note> resultNotes = noteService.getAllNotes();

        verify(noteRepository, times(1)).findAll();

        assertIterableEquals(mockNotes, resultNotes);
    }
 @Test
    void shouldUpdateNote_Test() {
        Note existNote = new Note(1, LocalDate.now(), "testTitle", "testText");
        Note updatetNote = new Note(1, LocalDate.now(), "testTitleUpdate", "testTextUpdate");

        when(noteRepository.findById(existNote.getId())).thenReturn(Optional.of(existNote));
        when(noteRepository.save(existNote)).thenReturn(updatetNote);

        Note result = noteService.updateNote(existNote.getId(), updatetNote);

        assertEquals(updatetNote.getTitle(), result.getTitle());
        assertEquals(updatetNote.getText(), result.getText());
    }

@Service
public class NoteServiceImpl implements NoteService {
   private final NoteRepository noteRepository;

    @Autowired
    public NoteServiceImpl(NoteRepository noteRepository) {
        this.noteRepository = noteRepository;
    }

    @Override
    public Note createNote(Note note) {
        note.setDate(LocalDate.now());
        return noteRepository.save(note);
    }

    @Override
    public List<Note> getAllNotes() {
        List<Note> notes = noteRepository.findAll();
        if (notes.isEmpty()) {
            throw new EntityNotFoundException("List is empty");
        }
        return notes;
    }

    @Override
    public Note getNoteById(Integer id) {
        return noteRepository.findById(id).orElseThrow(() -> new EntityNotFoundException("Not found note"));
        
  @Override
    public void deleteAllNotes() {
       getAllNotes();
        noteRepository.deleteAll();
    }
    
    @Override
    public void deleteById(Integer id) {
        Note note = noteRepository.findById(id).orElseThrow(() -> new EntityNotFoundException("Note not found"));
        noteRepository.delete(note);
    }

    @Override
    public Note updateNote(Integer id, Note note) {
        Note presentNote = getNoteById(id);
        presentNote.setTitle(note.getTitle());
        presentNote.setText(note.getText());
        return noteRepository.save(presentNote);
    }
}

@Test
void shouldDeleteNoteById_Test() {

  Note note = new Note(1, LocalDate.now(), "testTitle", "testText");

  noteRepository.save(note);

  noteService.deleteById(note.getId());

  assertTrue(noteRepository.findById(note.getId()).isEmpty());
  
}

@Test
void whenDeleteSuccess_NoteNotExist() {
    note.deleteById(1);
    assertFalse(noteChecker.noteExist(1));
}

@Test
void whenDeleteSuccess_NoteNotExist() {
    int id = idFetcher.fetchNoteIdByTitle("title");
    note.deleteById(id);
    assertFalse(noteChecker.noteExist(id));
}