Einführung und Verwendung von Spring Boot Junit-Unit-Tests

Unit-Test (Modultest): Es handelt sich um einen kleinen Codeabschnitt, der vom Entwickler geschrieben wurde, um zu überprüfen, ob eine kleine und klare Funktion des zu testenden Codes korrekt ist. Im Allgemeinen wird ein Komponententest verwendet, um das Verhalten einer bestimmten Funktion unter einer bestimmten Bedingung (oder einem bestimmten Szenario) zu bestimmen. Sie können beispielsweise einen großen Wert in eine sortierte Liste einfügen und dann sicherstellen, dass der Wert am Ende der Liste angezeigt wird. Alternativ können Sie Zeichen, die einem Muster entsprechen, aus einer Zeichenfolge entfernen und dann bestätigen, dass die Zeichenfolge diese Zeichen tatsächlich nicht mehr enthält.

Einfach ausgedrückt besteht ein Unit-Test darin, das kleinste Funktionsmodul in Ihrem Programm zu testen. In der c-Sprache kann es sich um eine Funktion handeln, in Java kann es sich um eine Methode oder Klasse handeln.

Der Zweck besteht darin, die Qualität des Codes zu verbessern.

Junit, eine alte Technologie, wird jetzt erneut erwähnt, nicht aus irgendeinem anderen Grund, sondern in gewissem Maße, um ihre Bedeutung im Projekt zu veranschaulichen.

Wenn Junit-Anwendungsfälle vollständig gemäß den Standards geschrieben sind und den größten Teil des Geschäftscodes im Projekt abdecken, sollte dieser nach meinen eigenen Gefühlen und Erfahrungen nicht mehr als die Hälfte betragen.

Ich habe gerade vor einiger Zeit einige Beiträge über SpringBoot geschrieben. Jetzt nehme ich Junit heraus und spreche darüber aus mehreren Aspekten, die für einige Anfänger als Referenz angesehen werden können.

Dann lassen Sie uns kurz darüber sprechen, warum wir Testfälle schreiben sollten

Es kann das Weglassen von Testpunkten vermeiden und die Testeffizienz verbessern

2. Es kann automatisch getestet und überprüft werden, bevor das Projekt verpackt wird

3. Es kann das Auftreten neuer Probleme, die durch Änderungen verursacht werden, umgehend erkennen den Code und lösen Sie sie rechtzeitig

Dann erklärt dieser Artikel, wie man Junit aus den folgenden Punkten verwendet, viel bequemer als 3. Die Hauptsache ist, dass Version 4 Nr erfordert mehr das Methodenbenennungsformat und es besteht keine Notwendigkeit, TestCase Everything is Implemented basierend auf Anmerkungen zu erben.

1. So verwenden Sie Junit

, um eine gewöhnliche Java-Klasse im SpringBoot-Webprojekt zu erstellen. In Junit4 besteht keine Notwendigkeit, die TestCase-Klasse zu erben.

Da wir ein Webprojekt sind, fügen Sie der erstellten Java-Klasse Anmerkungen hinzu:

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

Dann können Sie die Testmethode schreiben , die Testmethode kann mit der @Test-Annotation annotiert werden.

In dieser Klasse können wir wie gewohnt direkt @Autowired verwenden, um die Klasseninstanz einzufügen, die wir testen möchten.

Das Folgende ist der vollständige Code:

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);
  }

}

Als nächstes müssen Sie unzählige hinzufügen Testklasse, schreiben Sie unzählige Testmethoden, um die Wirksamkeit des von uns entwickelten Programms sicherzustellen.

2. Einführung in grundlegende Annotationen von JUnit

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

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

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

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

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

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

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

@RunWith

Es gibt viele In JUnit ist jeder Runner für den Aufruf Ihres Testcodes verantwortlich. Jeder Runner hat seine eigenen speziellen Funktionen. Sie müssen einen anderen Runner auswählen, um Ihren Testcode entsprechend Ihren Anforderungen auszuführen.

Wenn wir lediglich normale Java-Tests durchführen und keine Spring-Webprojekte einbeziehen, können Sie die Annotation @RunWith weglassen, sodass das System automatisch den Standard-Runner zum Ausführen Ihres Codes verwendet.

3. Parametrisierter Test

Der von Junit bereitgestellte parametrisierte Test muss @RunWith(Parameterized.class) verwenden

Jedoch weil Junit verwendet @RunWith, um einen Runner anzugeben. In häufigeren Fällen müssen wir @RunWith(SpringJUnit4ClassRunner.class) verwenden, um unsere Spring-Engineering-Methoden zu testen. Daher verwenden wir AssertArrayEquals, um die Methode mit mehreren Möglichkeiten zu testen.

Das Folgende ist ein einfaches Beispiel für einen parametrisierten Test:

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},
    });
  }
}

4

Normalerweise schreiben wir 5 Testklassen und müssen sie einzeln ausführen.

Verpacken von Tests bedeutet, eine neue Klasse hinzuzufügen, andere gemeinsam geschriebene Testklassen zu konfigurieren und diese Klasse dann direkt auszuführen, um den Zweck zu erreichen, mehrere andere Tests gleichzeitig auszuführen.

Der Code lautet wie folgt:

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

5. Verwenden Sie Junit, um das HTTP zu testen API-Schnittstelle

Wir können diese direkt zum Testen unserer Rest-API verwenden. Wenn die internen Unit-Testanforderungen nicht sehr streng sind, stellen wir sicher, dass die externe API vollständig getestet wird, da die API viele interne aufruft Stellen wir uns das wie einen Integrationstest vor.

Das Folgende ist ein einfaches Beispiel:

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"));
  }

}

6. Ausgabe erfassen

Verwenden Sie OutputCapture, um die gesamte Ausgabe zu erfassen, nachdem die angegebene Methode mit der Ausführung begonnen hat, einschließlich der System.out-Ausgabe und des Protokollprotokolls.

OutputCapture muss mit @Rule annotiert werden und das instanziierte Objekt muss mit public dekoriert werden, wie im folgenden Code gezeigt:

@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"));
  }
}

Das obige ist der detaillierte Inhalt vonEinführung und Verwendung von Spring Boot Junit-Unit-Tests. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!