Soll ich schreiben von Unit-Tests für CRUD-Operationen, wenn ich bereits die Integration-Tests?

Wenn die meisten Ihrer Dienste einfach durchlassen, um Ihre daos und Ihre daos wenig tun, aber Methoden aufgerufen werden, die auf Spring HibernateTemplate oder JdbcTemplate dann Sie sind richtig, dass unit-tests nicht wirklich etwas beweisen, dass Ihre integration tests bereits beweisen. Allerdings mit unit-tests vorhanden sind wertvoll für alle üblichen Gründen.

Da unit tests nur zum testen einzelner Klassen, im Speicher ausgeführt, mit keine Festplatten-oder Netzwerk-Zugang, und nie wirklich testen mehrere Klassen gemeinsam, Sie gehen in der Regel wie diese:

• Service unit-tests, mock die daos.
• Dao unit-tests, mock-Datenbank-Treiber (oder Frühling-Vorlage) oder verwenden Sie eine eingebettete Datenbank (super einfach im Frühjahr 3).

Unit-Tests der service, der einfach nur durchläuft, um das dao, können Sie mock so:

@Before
public void setUp() {
    service = new EventServiceImpl();
    dao = mock(EventDao.class);
    service.EventDao = dao;
}

@Test
public void creationDelegatesToDao() {
    service.createEvent(sampleEvent);
    verify(dao).createEvent(sampleEvent);
}

@Test(expected=EventExistsException.class)
public void creationPropagatesExistExceptions() {
    doThrow(new EventExistsException()).when(dao).createEvent(sampleEvent);
    service.createEvent(sampleEvent);
}

@Test
public void updatesDelegateToDao() {
    service.updateEvent(sampleEvent);
    verify(dao).updateEvent(sampleEvent);
}

@Test
public void findingDelgatesToDao() {
    when(dao.findEventById(7)).thenReturn(sampleEvent);
    assertThat(service.findEventById(7), equalTo(sampleEvent));

    service.findEvents("Alice", 1, 5);
    verify(dao).findEventsByName("Alice", 1, 5);

    service.findEvents(null, 10, 50);
    verify(dao).findAllEvents(10, 50);
}

@Test
public void deletionDelegatesToDao() {
    service.deleteEvent(sampleEvent);
    verify(dao).deleteEvent(sampleEvent);
}

Aber ist das wirklich eine gute Idee? Diese Mockito Behauptungen sind zu behaupten, dass eine dao-Methode genannt habe, nicht, dass es Tat, was erwartet wurde! Sie erhalten Ihren Versicherungsschutz zahlen, aber Sie sind mehr oder weniger verbindlich Ihre tests, um eine Implementierung des dao. Autsch.

Nun dieses Beispiel angenommen, dass der service hatte keine wirkliche business-Logik. Normalerweise werden die Dienstleistungen haben, die business-Logik in addtion zu dao nennt, und Sie werden sicherlich müssen diese testen.

Nun, für unit-testing, daos, ich möchte eine eingebettete Datenbank.

private EmbeddedDatabase database;
private EventDaoJdbcImpl eventDao = new EventDaoJdbcImpl();

@Before
public void setUp() {
    database = new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("schema.sql")
            .addScript("init.sql")
            .build();
    eventDao.jdbcTemplate = new JdbcTemplate(database);
}

@Test
public void creatingIncrementsSize() {
    Event e = new Event(9, "Company Softball Game");

    int initialCount = eventDao.findNumberOfEvents();
    eventDao.createEvent(e);
    assertThat(eventDao.findNumberOfEvents(), is(initialCount + 1));
}

@Test
public void deletingDecrementsSize() {
    Event e = new Event(1, "Poker Night");

    int initialCount = eventDao.findNumberOfEvents();
    eventDao.deleteEvent(e);
    assertThat(eventDao.findNumberOfEvents(), is(initialCount - 1));
}

@Test
public void createdEventCanBeFound() {
    eventDao.createEvent(new Event(9, "Company Softball Game"));
    Event e = eventDao.findEventById(9);
    assertThat(e.getId(), is(9));
    assertThat(e.getName(), is("Company Softball Game"));
}

@Test
public void updatesToCreatedEventCanBeRead() {
    eventDao.createEvent(new Event(9, "Company Softball Game"));
    Event e = eventDao.findEventById(9);
    e.setName("Cricket Game");
    eventDao.updateEvent(e);
    e = eventDao.findEventById(9);
    assertThat(e.getId(), is(9));
    assertThat(e.getName(), is("Cricket Game"));
}

@Test(expected=EventExistsException.class)
public void creatingDuplicateEventThrowsException() {
    eventDao.createEvent(new Event(1, "Id1WasAlreadyUsed"));
}

@Test(expected=NoSuchEventException.class)
public void updatingNonExistentEventThrowsException() {
    eventDao.updateEvent(new Event(1000, "Unknown"));
}

@Test(expected=NoSuchEventException.class)
public void deletingNonExistentEventThrowsException() {
    eventDao.deleteEvent(new Event(1000, "Unknown"));
}

@Test(expected=NoSuchEventException.class)
public void findingNonExistentEventThrowsException() {
    eventDao.findEventById(1000);
}

@Test
public void countOfInitialDataSetIsAsExpected() {
    assertThat(eventDao.findNumberOfEvents(), is(8));
}

Ich noch nennen dies ein unit-test auch wenn die meisten Menschen nennen könnte es ein integration-test. Die embedded-Datenbank befindet sich im Speicher, und es ist und brachte nach unten, wenn die tests ausgeführt werden. Aber dies beruht auf der Tatsache, dass die eingebettete Datenbank sieht genauso aus, wie die Produktion-Datenbank. Wird das der Fall sein? Wenn nicht, dann ist all die Arbeit war ziemlich nutzlos. Wenn dem so ist, dann, wie Sie sagen, diese tests sind dabei nichts anderes als die integration-tests. Aber ich kann Ihnen auf Nachfrage mit mvn test und ich habe das Vertrauen zu überarbeiten.

Deshalb Schreibe ich diese unit-tests sowieso und treffen meiner Berichterstattung Ziele. Wenn ich Schreibe, integration tests, die ich geltend machen, dass eine HTTP-Anforderung gibt den erwarteten HTTP-Antwort. Ja, es fasst die unit-tests, aber hey, wenn Sie üben, TDD haben Sie die unit-tests geschrieben, bevor der eigentliche dao-Implementierung sowieso.

Beim schreiben von unit-tests nach der dao, dann kann man Sie natürlich auch keinen Spaß zu schreiben. Die TDD-Literatur ist voll von Warnungen darüber, wie das schreiben von tests nach Ihren code fühlt sich an wie Arbeit und niemand will es tun.

TL;DR: der Integrationstests wird, subsumieren Ihre unit-tests und in diesem Sinne die unit-tests sind nicht das hinzufügen einer echten Prüfung Wert. Allerdings, wenn Sie haben eine hohe Deckkraft unit test suite haben Sie das Vertrauen zu überarbeiten. Aber natürlich, wenn die dao ist trivial Aufruf von Spring data access-Vorlage, dann können Sie nicht die Umgestaltung. Aber man weiß ja nie. Und schließlich, obwohl, wenn die unit-tests geschrieben werden zuerst in TDD-Stil, die Sie haben Sie trotzdem.