TOC

Declarações Spring Assert

Declarações Spring Assert

1. Visão geral

Neste tutorial, vamos nos concentrar e descrever o propósito da classeSpring Assert e demonstrar como usá-la.

2. Objetivo da classeAssert

A classe SpringAssert nos ajuda a validar argumentos. By using methods of the Assert class, we can write assumptions which we expect to be true. E se eles não forem atendidos, uma exceção de tempo de execução é lançada.

Cada método deAssert pode ser comparado com a instrução Javaassert. A instrução Javaassert lança umError em tempo de execução se sua condição falhar. O fato interessante é que essas afirmações podem ser desativadas.

Aqui estão algumas características dos métodos de SpringAssert:

  • Os métodos deAssert são estáticos

  • Eles jogamIllegalArgumentException ouIllegalStateException

  • O primeiro parâmetro é geralmente um argumento para validação ou uma condição lógica para verificar

  • O último parâmetro é geralmente uma mensagem de exceção que é exibida se a validação falhar

  • A mensagem pode ser passada como um parâmetroString ou como um parâmetroSupplier<String> 

Observe também que, apesar do nome semelhante, as asserções Spring não têm nada em comum com as asserções deJUnite outras estruturas de teste. As asserções do Spring não são para teste, mas para depuração.

3. Exemplo de Uso

Vamos definir uma classeCar com um método públicodrive(): 

public class Car {
    private String state = "stop";

    public void drive(int speed) {
        Assert.isTrue(speed > 0, "speed must be positive");
        this.state = "drive";
        // ...
    }
}

Podemos ver como a velocidade deve ser um número positivo. A linha acima é uma maneira curta de verificar a condição e lançar uma exceção se a condição falhar: 

if (!(speed > 0)) {
    throw new IllegalArgumentException("speed must be positive");
}

Cada método público deAssert contém aproximadamente este código - um bloco condicional com uma exceção de tempo de execução da qual o aplicativo não deve se recuperar.

Se tentarmos chamar o métododrive() com um argumento negativo, uma exceçãoIllegalArgumentException será lançada: 

Exception in thread "main" java.lang.IllegalArgumentException: speed must be positive

4. Asserções Lógicas

4.1. é verdade()

Esta afirmação foi discutida acima. Ele aceita uma condiçãobooleane lança umIllegalArgumentException quando a condição é falsa.

4.2. Estado()

O métodostate() tem a mesma assinatura deisTrue(), mas lança oIllegalStateException.

Como o nome sugere, ele deve ser usado quando o método não deve ser continuado devido a um estado ilegal do objeto.

Imagine que não podemos chamar o métodofuel() se o carro estiver funcionando. Vamos usar a afirmaçãostate() neste caso: 

public void fuel() {
    Assert.state(this.state.equals("stop"), "car must be stopped");
    // ...
}

Obviamente, podemos validar tudo usando asserções lógicas. Porém, para melhor legibilidade, podemos usar asserções adicionais que tornam nosso código mais expressivo.

5. Object and Type Assertions

5.1. não nulo()

Podemos assumir que um objeto não énull usando o métodonotNull(): 

public void сhangeOil(String oil) {
    Assert.notNull(oil, "oil mustn't be null");
    // ...
}

5.2. isNull()

Por outro lado, podemos verificar se um objeto énull usando o métodoisNull(): 

public void replaceBattery(CarBattery carBattery) {
    Assert.isNull(
      carBattery.getCharge(),
      "to replace battery the charge must be null");
    // ...
}

5.3. isInstanceOf()

Para verificar se um objeto é uma instância de outro objeto do tipo específico, podemos usar o métodoisInstanceOf(): 

public void сhangeEngine(Engine engine) {
    Assert.isInstanceOf(ToyotaEngine.class, engine);
    // ...
}

Em nosso exemplo, a verificação passa com sucesso porqueToyotaEngine é uma subclasse deEngine.

5.4. isAssignable()

Para verificar os tipos, podemos usarAssert.isAssignable(): 

public void repairEngine(Engine engine) {
    Assert.isAssignable(Engine.class, ToyotaEngine.class);
    // ...
}

Duas afirmações recentes representam um relacionamentois-a.

6. Asserções de texto

Asserções de texto são usadas para realizar verificações em argumentosString.

6.1. hasLength()

Podemos verificar se aString não está em branco, o que significa que contém pelo menos um espaço em branco, usando o métodohasLength(): 

public void startWithHasLength(String key) {
    Assert.hasLength(key, "key must not be null and must not the empty");
    // ...
}

6.2. hasText()

Podemos fortalecer a condição e verificar se umString contém pelo menos um caractere diferente de espaço em branco, usando o métodohasText(): 

public void startWithHasText(String key) {
    Assert.hasText(
      key,
      "key must not be null and must contain at least one non-whitespace  character");
    // ...
}

6.3. doesNotContain()

Podemos determinar se um argumentoString não contém uma substring específica usando o métododoesNotContain(): 

public void startWithNotContain(String key) {
    Assert.doesNotContain(key, "123", "key mustn't contain 123");
    // ...
}

7. Coleta e asserções de mapa

7.1. notEmpty() para coleções

Como o nome diz, o métodonotEmpty() afirma que uma coleção não está vazia, o que significa que não énulle contém pelo menos um elemento: 

public void repair(Collection repairParts) {
    Assert.notEmpty(
      repairParts,
      "collection of repairParts mustn't be empty");
    // ...
}

7.2. notEmpty() para mapas

O mesmo método está sobrecarregado para mapas, e podemos verificar se um mapa não está vazio e contém pelo menos uma entrada: 

public void repair(Map repairParts) {
    Assert.notEmpty(
      repairParts,
      "map of repairParts mustn't be empty");
    // ...
}

8. Asserções de matriz

8.1. notEmpty() para matrizes

Finalmente, podemos verificar se uma matriz não está vazia e contém pelo menos um elemento usando o métodonotEmpty(): 

public void repair(String[] repairParts) {
    Assert.notEmpty(
      repairParts,
      "array of repairParts mustn't be empty");
    // ...
}

8.2. noNullElements()

Podemos verificar que uma matriz não contém elementosnull usando o métodonoNullElements(): 

public void repairWithNoNull(String[] repairParts) {
    Assert.noNullElements(
      repairParts,
      "array of repairParts mustn't contain null elements");
    // ...
}

Observe que esta verificação ainda passa se o array estiver vazio, desde que não haja elementosnull nele.

9. Conclusão

Neste artigo, exploramos a classeAssert. Essa classe é amplamente usada na estrutura Spring, mas poderíamos facilmente escrever código mais robusto e expressivo aproveitando-o.

Como sempre, o código completo para este artigo pode ser encontrado emGitHub project.

Related