Introduction et utilisation des tests unitaires Spring Boot Junit-javaDidacticiel-php.cn

Test unitaire (test de module) : Il s'agit d'un petit morceau de code écrit par le développeur pour vérifier si une fonction petite et claire du code testé est correcte. De manière générale, un test unitaire est utilisé pour déterminer le comportement d'une fonction spécifique dans une condition (ou un scénario) spécifique. Par exemple, vous pouvez placer une valeur élevée dans une liste triée, puis vous assurer que la valeur apparaît à la fin de la liste. Alternativement, vous pouvez supprimer les caractères correspondant à un modèle d'une chaîne, puis confirmer que la chaîne ne contient effectivement plus ces caractères.

En termes simples, les tests unitaires consistent à tester le plus petit module fonctionnel de votre programme. En langage c , cela peut être une fonction, en Java, cela peut être une méthode ou une classe.

Le but est d'améliorer la qualité du code.

Junit, une technologie ancienne, est désormais évoquée à nouveau, non pas pour autre chose, mais dans une certaine mesure, pour illustrer son importance dans le projet.

D'après mes propres sentiments et expériences, si les cas d'utilisation de Junit sont entièrement écrits selon les normes et couvrent la plupart du code métier du projet, ils ne devraient pas dépasser la moitié.

Je viens d'écrire quelques articles sur SpringBoot il y a quelque temps. Maintenant, je sors Junit et en parle sous plusieurs aspects, ce qui peut être considéré comme une référence pour certains novices.

Ensuite, parlons brièvement des raisons pour lesquelles nous devrions écrire des cas de test

1 Cela peut éviter l'omission de points de test. Afin d'effectuer de meilleurs tests, cela peut améliorer l'efficacité des tests.

2. Il peut être testé automatiquement et peut être testé et vérifié avant que le projet ne soit emballé

3. Il peut détecter rapidement l'émergence de nouveaux problèmes causés par la modification. le code et résolvez-les à temps

Ensuite, cet article explique comment utiliser Junit à partir des points suivants. Junit 4 est beaucoup plus pratique que 3. Vous pouvez comprendre les détails vous-même. L'essentiel est que la version 4 ne soit pas disponible. ne nécessite plus le format de nom de méthode et il n'est pas nécessaire d'hériter de TestCase. Tout est implémenté sur la base d'annotations.

1. Comment utiliser Junit

pour créer une classe Java ordinaire dans le projet Web SpringBoot Dans Junit4, il n'est pas nécessaire d'hériter de la classe TestCase.

Parce que nous sommes un projet Web, ajoutez des annotations à la classe Java créée :

@RunWith(SpringJUnit4ClassRunner.class) // SpringJUnit支持，由此引入Spring-Test框架支持！ 
@SpringApplicationConfiguration(classes = SpringBootSampleApplication.class) // 指定我们SpringBoot工程的Application启动类
@WebAppConfiguration // 由于是Web项目，Junit需要模拟ServletContext，因此我们需要给我们的测试类加上@WebAppConfiguration。

Copier après la connexion

Ensuite, vous pouvez écrire la méthode de test Oui , la méthode de test peut être annotée avec l'annotation @Test.

Dans cette classe, on peut directement @Autowired injecter l'instance de classe que l'on souhaite tester comme d'habitude.

Ce qui suit est le code complet :

package org.springboot.sample;

import static org.junit.Assert.assertArrayEquals;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springboot.sample.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

/**
 *
 * @author  单红宇(365384722)
 * @create  2016年2月23日
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootSampleApplication.class)
@WebAppConfiguration
public class StudentTest {

  @Autowired
  private StudentService studentService;

  @Test
  public void likeName() {
    assertArrayEquals(
        new Object[]{
            studentService.likeName("小明2").size() > 0,
            studentService.likeName("坏").size() > 0,
            studentService.likeName("莉莉").size() > 0
          }, 
        new Object[]{
            true,
            false,
            true
          }
    );
//   assertTrue(studentService.likeName("小明2").size() > 0);
  }

}

Copier après la connexion

Ensuite, vous devez ajouter d'innombrables Classe de test, écrivez d'innombrables méthodes de test pour garantir l'efficacité du programme que nous avons développé.

2. Introduction aux annotations de base de JUnit

//在所有测试方法前执行一次，一般在其中写上整体初始化的代码 
@BeforeClass

//在所有测试方法后执行一次，一般在其中写上销毁和释放资源的代码 
@AfterClass

//在每个测试方法前执行，一般用来初始化方法（比如我们在测试别的方法时，类中与其他测试方法共享的值已经被改变，为了保证测试结果的有效性，我们会在@Before注解的方法中重置数据） 
@Before

//在每个测试方法后执行，在方法执行完成后要做的事情 
@After

// 测试方法执行超过1000毫秒后算超时，测试将失败 
@Test(timeout = 1000)

// 测试方法期望得到的异常类，如果方法执行没有抛出指定的异常，则测试失败 
@Test(expected = Exception.class)

// 执行测试时将忽略掉此方法，如果用于修饰类，则忽略整个类 
@Ignore(“not ready yet”) 
@Test

@RunWith

Copier après la connexion

Il en existe de nombreuses dans JUnit, chaque Runner est responsable de l'appel de votre code de test. Chaque Runner a ses propres fonctions spéciales. Vous devez choisir un Runner différent pour exécuter votre code de test en fonction de vos besoins.

Si nous effectuons simplement des tests Java ordinaires et n'impliquons pas de projets Web Spring, vous pouvez omettre l'annotation @RunWith, afin que le système utilise automatiquement le Runner par défaut pour exécuter votre code.

3. Test paramétré

Le test paramétré fourni par Junit doit utiliser @RunWith(Parameterized.class)

Cependant, parce que Junit utilise @RunWith pour spécifier un Runner, dans la plupart des cas, nous devons utiliser @RunWith(SpringJUnit4ClassRunner.class) pour tester nos méthodes d'ingénierie Spring, nous utilisons donc assertArrayEquals pour tester la méthode avec plusieurs possibilités.

Ce qui suit est un exemple simple de tests paramétrés :

package org.springboot.sample;

import static org.junit.Assert.assertTrue;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class ParameterTest {

  private String name;
  private boolean result;

  /**
   * 该构造方法的参数与下面@Parameters注解的方法中的Object数组中值的顺序对应
   * @param name
   * @param result
   */
  public ParameterTest(String name, boolean result) {
    super();
    this.name = name;
    this.result = result;
  }

  @Test
  public void test() {
    assertTrue(name.contains("小") == result);
  }

  /**
   * 该方法返回Collection
   *
   * @return
   * @author SHANHY
   * @create 2016年2月26日
   */
  @Parameters
  public static Collection<?> data(){
    // Object 数组中值的顺序注意要和上面的构造方法ParameterTest的参数对应
    return Arrays.asList(new Object[][]{
      {"小明2", true},
      {"坏", false},
      {"莉莉", false},
    });
  }
}

Copier après la connexion

Normalement, nous écrivons 5 classes de test, et nous devons les exécuter une par une.

Les tests de packaging signifient ajouter une nouvelle classe, configurer d'autres classes de test que nous avons écrites ensemble, puis exécuter cette classe directement pour atteindre l'objectif d'exécuter plusieurs autres tests en même temps.

Le code est le suivant :

@RunWith(Suite.class) 
@SuiteClasses({ATest.class, BTest.class, CTest.class}) 
public class ABCSuite {
  // 类中不需要编写代码
}

Copier après la connexion

5. Utilisez Junit pour tester le HTTP. Interface API

Nous pouvons l'utiliser directement pour tester notre API Rest Si les exigences de tests unitaires internes ne sont pas très strictes, nous nous assurons que l'API externe est entièrement testée, car l'API appellera de nombreux internes. méthodes. Disons-le comme un test d'intégration.

Ce qui suit est un exemple simple :

package org.springboot.sample;

import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.hamcrest.Matchers;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.boot.test.TestRestTemplate;
import org.springframework.boot.test.WebIntegrationTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

/**
 *
 * @author  单红宇(365384722)
 * @create  2016年2月23日
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootSampleApplication.class)
//@WebAppConfiguration // 使用@WebIntegrationTest注解需要将@WebAppConfiguration注释掉
@WebIntegrationTest("server.port:0")// 使用0表示端口号随机，也可以具体指定如8888这样的固定端口
public class HelloControllerTest {

  private String dateReg;
  private Pattern pattern;
  private RestTemplate template = new TestRestTemplate();
  @Value("${local.server.port}")// 注入端口号
  private int port;

  @Test
  public void test3(){
    String url = "http://localhost:"+port+"/myspringboot/hello/info";
    MultiValueMap<String, Object> map = new LinkedMultiValueMap<String, Object>(); 
    map.add("name", "Tom"); 
    map.add("name1", "Lily");
    String result = template.postForObject(url, map, String.class);
    System.out.println(result);
    assertNotNull(result);
    assertThat(result, Matchers.containsString("Tom"));
  }

}

Copier après la connexion

6. Capturer la sortie

Utilisez OutputCapture pour capturer toutes les sorties après le démarrage de l'exécution de la méthode spécifiée, y compris la sortie System.out et le journal.

OutputCapture doit être annoté avec @Rule et l'objet instancié doit être modifié avec public, comme indiqué dans le code suivant :

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootSampleApplication.class)
//@WebAppConfiguration // 使用@WebIntegrationTest注解需要将@WebAppConfiguration注释掉
@WebIntegrationTest("server.port:0")// 使用0表示端口号随机，也可以具体指定如8888这样的固定端口
public class HelloControllerTest {

  @Value("${local.server.port}")// 注入端口号
  private int port;

  private static final Logger logger = LoggerFactory.getLogger(StudentController.class);

  @Rule
  // 这里注意，使用@Rule注解必须要用public
  public OutputCapture capture = new OutputCapture();

  @Test
  public void test4(){
    System.out.println("HelloWorld");
    logger.info("logo日志也会被capture捕获测试输出");
    assertThat(capture.toString(), Matchers.containsString("World"));
  }
}

Copier après la connexion

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!