Asserzioni JUnit

6.1 afferma

Gli assert sono controlli speciali che possono essere inseriti in diversi punti del codice. Il loro compito è determinare che qualcosa è andato storto. O meglio, per verificare che tutto vada come dovrebbe. Questo è "secondo necessità" e ti consentono di impostarlo in vari modi.

Hai già incontrato alcune asserzioni nel codice sopra. Il primo sta verificando l'uguaglianza degli oggetti. Se gli oggetti non sono uguali, verrà lanciata un'eccezione e il test avrà esito negativo.

L'ordine di confronto è importante qui , perché JUnit nel rapporto finale scriverà qualcosa come "valore 1 ricevuto, ma 3 era previsto". Il formato generale per tale controllo è:

assertEquals(standard , meaning)

Esempio:

@Test
public void whenAssertingEquality () {
    String expected = "3.1415";
    String actual = "3";

    assertEquals(expected, actual);
}

6.2 Metodi assertEquals, assertTrue, assertFalse

Di seguito elencherò i metodi più popolari: le affermazioni. Con i loro nomi è del tutto possibile indovinare come funzionano. Ma scriverò comunque una breve spiegazione:

Alcuni di questi metodi sembrano ridondanti. Perché usare assertSame(a, b) quando puoi semplicemente scrivere assertTrue(a == b) ?

Il punto è che assert è un metodo molto intelligente. Fa molte cose utili, inclusa la scrittura di informazioni sull'errore nel log . Nel primo caso, scriverà che era previsto l'oggetto A, ma è stato ricevuto l'oggetto B. Nel secondo caso, scriverà semplicemente che era previsto true .

Quando hai centinaia di test, in particolare quelli in esecuzione su un server di test dedicato, avere registri dettagliati può essere molto utile. Penso che tu capisca cosa intendo.

Esempio di confronto tra array:

@Test
public void whenAssertingArraysEquality() {
    char[] expected = {'J','u','n','i','t'};
    char[] actual = "Junit".toCharArray();

    assertArrayEquals(expected, actual);
}

6.3 Metodo assertAll

Come accennato in precedenza, il metodo assert non solo esegue un controllo, ma scrive anche molte informazioni su oggetti comparabili nel registro.

Facciamo un confronto:

Address address = unitUnderTest.methodUnderTest();
assertEquals("Washington", address.getCity());
assertEquals("Oracle Parkway", address.getStreet());
assertEquals("500", address.getNumber());

Ma se uno dei parametri non corrisponde, il resto non verrà verificato. Ma vorrei che si verificassero ancora e che i loro risultati fossero registrati nel registro. Ma allo stesso tempo, se almeno un controllo fallisce, il test fallisce comunque.

C'è un metodo speciale per questo - assertAll() . Come primo argomento, ci vuole un commento da scrivere nel log, e quindi un numero qualsiasi di funzioni assert.

Ecco come il nostro esempio verrebbe riscritto con esso:

Address address = unitUnderTest.methodUnderTest();
assertAll("Complex address comparison script",
    () -> assertEquals("Washington", address.getCity()),
    () -> assertEquals("Oracle Parkway", address.getStreet()),
    () -> assertEquals("500", address.getNumber())
);

Quindi, se l'indirizzo non è corretto, qualcosa di simile verrà scritto nel registro:

	Complex scenario comparison address (3 failures)
	expected: <Washington> but was: <Seattle>
    expected: <Oracle Parkway> but was: <Main Street>
    expected: <500> but was: <5772>

6.4 Metodo assertTimeout

Ricordi l' annotazione @Timeout ? Ha permesso di controllare il tempo di esecuzione dell'intero metodo. Ma a volte è utile impostare restrizioni sull'esecuzione di alcune parti del codice all'interno del metodo. Puoi usare assertTimeout() per questo .

Il tempo viene passato come primo parametro e il codice (funzione) che deve essere eseguito entro il tempo specificato viene passato come secondo. Esempio:

@Test
public void whenAssertingTimeout() {
    assertTimeout(
  	ofSeconds(2),
  	() -> {
    	// pause for one second
    	Thread.sleep(1000);
  	}
	);
}

La classe Assert ha 12 varianti del metodo assertTimeout() . Se vuoi saperne di più su di loro, benvenuto nella documentazione ufficiale .

6.5 Metodo assertThrows

Molto spesso ci sono situazioni in cui è necessario assicurarsi che in una determinata situazione il codice generi l'eccezione giusta: rileva un errore e genera l'eccezione giusta. Questa è una situazione molto comune.

In questo caso, c'è un altro utile metodo assert - questo è assertThrows() . Il formato generale della sua chiamata è:

assertThrows(exception , code)

Fondamentalmente, è molto simile al metodo assertTimeout() , solo che controlla che il codice specificato generi l'eccezione corretta. Esempio:

@Test
void whenAssertingException() {
    Throwable exception = assertThrows(
  	IllegalArgumentException.class,
  	() -> {
      	throw new IllegalArgumentException("Exception message");
  	}
    );
    assertEquals("Exception message", exception.getMessage());
}