Ujian Integrasi dengan Maven

1. Gambaran keseluruhan

Maven adalah alat binaan yang paling popular di ruang Java, sementara pengujian integrasi adalah bahagian penting dari proses pengembangan. Oleh itu, adalah pilihan semula jadi untuk mengkonfigurasi dan melaksanakan ujian integrasi dengan Maven.

Dalam tutorial ini, kita akan membahas beberapa cara yang berbeza untuk menggunakan Maven untuk ujian integrasi dan untuk memisahkan ujian integrasi dari ujian unit.

2. Persiapan

Untuk menjadikan kod demonstrasi hampir dengan projek dunia nyata, kami akan menyediakan aplikasi JAX-RS. Aplikasi ini disebarkan ke pelayan sebelum pelaksanaan ujian integrasi dan dibongkar sesudahnya.

2.1. Konfigurasi Maven

Kami akan membina aplikasi REST kami di sekitar Jersey - pelaksanaan rujukan JAX-RS. Pelaksanaan ini memerlukan beberapa pergantungan:

 org.glassfish.jersey.containers jersey-container-servlet-core 2.27   org.glassfish.jersey.inject jersey-hk2 2.27 

Kita boleh mendapatkan versi terbaru dari kebergantungan ini di sini dan di sini.

Kami akan menggunakan plugin Jetty Maven untuk menyediakan persekitaran ujian. Plugin ini memulakan pelayan Jetty semasa fasa ujian pra-integrasi kitaran hidup Maven build, kemudian menghentikannya dalam fasa ujian pasca-integrasi .

Inilah cara kami mengkonfigurasi pemalam Jetty Maven di pom.xml :

 org.eclipse.jetty jetty-maven-plugin 9.4.11.v20180605   8999  quit 9000    start-jetty pre-integration-test  start    stop-jetty post-integration-test  stop    

Apabila pelayan Jetty dimulakan, ia akan mendengar di port 8999 . The stopKey dan stopPort elemen konfigurasi digunakan semata-mata oleh plugin ini stop matlamat dan nilai mereka tidak penting daripada perspektif kami.

Di sinilah mencari versi terbaru plugin Jetty Maven.

Perkara lain yang perlu diperhatikan ialah kita mesti menetapkan elemen pembungkusan dalam fail pom.xml untuk berperang , jika tidak, pemalam Jetty tidak dapat memulakan pelayan:

war

2.2. Membuat Aplikasi REST

Titik akhir aplikasi sangat mudah - mengembalikan mesej selamat datang apabila permintaan GET menyentuh akar konteks:

@Path("/") public class RestEndpoint { @GET public String hello() { return "Welcome to Baeldung!"; } }

Ini adalah bagaimana kami mendaftarkan kelas titik akhir dengan Jersey:

package com.baeldung.maven.it; import org.glassfish.jersey.server.ResourceConfig; public class EndpointConfig extends ResourceConfig { public EndpointConfig() { register(RestEndpoint.class); } }

Untuk mengetahui pelayan Jetty mengenai aplikasi REST kami, kami dapat menggunakan deskriptor penyebaran web.xml klasik :

  rest-servlet org.glassfish.jersey.servlet.ServletContainer  javax.ws.rs.Application com.baeldung.maven.it.EndpointConfig    rest-servlet /*  

Deskriptor ini mesti diletakkan di direktori / src / main / webapp / WEB-INF untuk dikenali oleh pelayan.

2.3. Kod Ujian Sisi Pelanggan

Semua kelas ujian dalam bahagian berikut mengandungi satu kaedah:

@Test public void whenSendingGet_thenMessageIsReturned() throws IOException { String url = "//localhost:8999"; URLConnection connection = new URL(url).openConnection(); try (InputStream response = connection.getInputStream(); Scanner scanner = new Scanner(response)) { String responseBody = scanner.nextLine(); assertEquals("Welcome to Baeldung!", responseBody); } }

Seperti yang kita lihat, kaedah ini tidak lain hanyalah mengirim permintaan GET ke aplikasi web yang kami siapkan sebelumnya dan mengesahkan responsnya.

3. Ujian Integrasi dalam Tindakan

Perkara penting yang perlu diperhatikan mengenai ujian integrasi ialah kaedah ujian sering memerlukan masa yang lama untuk dijalankan.

Akibatnya, kita harus mengecualikan ujian integrasi dari kitaran hidup bawaan, sehingga tidak memperlambat keseluruhan proses setiap kali kita membuat projek.

Cara mudah untuk memisahkan ujian integrasi adalah dengan menggunakan profil binaan. Konfigurasi seperti ini membolehkan kita melaksanakan ujian integrasi hanya apabila perlu - dengan menentukan profil yang sesuai.

Pada bahagian yang mengikuti, kami akan mengkonfigurasi semua ujian integrasi dengan profil binaan.

4. Menguji Dengan Failsafe Plugin

Cara paling mudah untuk menjalankan ujian integrasi adalah dengan menggunakan plugin Maven failafe .

Secara lalai, Maven surefire plugin bermaksud melaksanakan ujian unit semasa ujian fasa, manakala yang selamat tersebut plugin berjalan ujian integrasi dalam integrasi ujian fasa .

Kita boleh menamakan kelas ujian dengan corak yang berbeza untuk plugin tersebut untuk mengambil ujian yang dilampirkan secara berasingan.

Konvensyen penamaan lalai yang dikuatkuasakan oleh surefire dan failafe adalah berbeza, oleh itu kita hanya perlu mengikuti konvensyen ini untuk memisahkan ujian unit dan integrasi.

Pelaksanaan plugin surefire merangkumi semua kelas yang namanya dimulakan dengan Test , atau berakhir dengan Test , Tests atau TestCase . Sebaliknya, plugin failafe melaksanakan kaedah ujian di kelas yang namanya bermula dengan IT , atau diakhiri dengan IT atau ITCase .

Di sinilah kita dapat mencari dokumentasi mengenai penyertaan ujian untuk pasti , dan inilah yang untuk failafe .

Mari tambahkan plugin failafe ke POM dengan konfigurasi lalai:

 failsafe    maven-failsafe-plugin 2.22.0    integration-test verify       

Pautan ini adalah tempat mencari versi terkini plugin failafe .

With the above configuration, the following test method will be executed in the integration-test phase:

public class RestIT { // test method shown in subsection 2.3 }

Since the Jetty server starts up in the pre-integration-test phase and shuts down in post-integration-test, the test we have just seen passes with this command:

mvn verify -Pfailsafe

We can also customize the naming patterns to include classes with different names:

 maven-failsafe-plugin 2.22.0   **/*RestIT **/RestITCase   ... 

5. Testing With the Surefire Plugin

Apart from the failsafe plugin, we can also use the surefire plugin to execute unit and integration tests in different phases.

Let's assume we want to name all integration tests with the suffix IntegrationTest. Since the surefire plugin runs tests with such a name in the test phase by default, we need to exclude them from the default execution:

 maven-surefire-plugin 2.22.0   **/*IntegrationTest   

The latest version of this plugin is here.

We've taken all test classes having a name ending with IntegrationTest out of the build lifecycle. It's time to put them back with a profile:

 surefire    maven-surefire-plugin 2.22.0   integration-test  test    none   **/*IntegrationTest        

Instead of binding the test goal of the surefire plugin to the test build phase, as usual, we bound it to the integration-test phase. The plugin will then kick in during the integration testing process.

Notice that we must set an exclude element to none to override the exclusion specified in the base configuration.

Now, let's define an integration test class with our naming pattern:

public class RestIntegrationTest { // test method shown in subsection 2.3 }

This test will be running with the command:

mvn verify -Psurefire

6. Testing With the Cargo Plugin

We can use the surefire plugin with the Maven cargo plugin. This plugin comes with built-in support for embedded servers, which are very useful for integration testing.

More details about this combination can be found here.

7. Testing With JUnit's @Category

A convenient way to selectively execute tests is to leverage the @Category annotation in the JUnit 4 framework. This annotation lets us exclude particular tests from unit testing, and include them in integration testing.

First off, we need an interface or class to work as a category identifier:

package com.baeldung.maven.it; public interface Integration { }

We can then decorate a test class with the @Category annotation and Integration identifier:

@Category(Integration.class) public class RestJUnitTest { // test method shown in subsection 2.3 }

Rather than declaring the @Category annotation on a test class, we can also use it at the method level to categorize individual test methods.

Excluding a category from the test build phase is simple:

 maven-surefire-plugin 2.22.0  com.baeldung.maven.it.Integration  

Including the Integration category in the integration-test phase is also straightforward:

 category    maven-failsafe-plugin 2.22.0   **/*  com.baeldung.maven.it.Integration     integration-test verify       

We can now run integration tests with a Maven command:

mvn verify -Pcategory

8. Adding a Separate Directory for Integration Tests

It's desirable at times to have a separate directory for integration tests. Organizing tests this way allows us to entirely isolate integration tests from unit tests.

We can use the Maven build helper plugin for this purpose:

 org.codehaus.mojo build-helper-maven-plugin 3.0.0   add-integration-test-source generate-test-sources  add-test-source    src/integration-test/java     

Here is where we can find the latest version of this plugin.

The configuration we've just seen adds a test source directory to the build. Let's add a class definition to that new directory:

public class RestITCase { // test method shown in subsection 2.3 }

It's time to run integration tests in this class:

mvn verify -Pfailsafe

Plugin Maven failafe akan melaksanakan kaedah dalam kelas ujian ini kerana konfigurasi yang kami tetapkan dalam subseksyen 3.1.

Direktori sumber ujian sering menggunakan direktori sumber. Kita boleh menambahkan direktori seperti itu dalam elemen pelaksanaan lain ke konfigurasi pemalam:

 ...  add-integration-test-resource generate-test-resources  add-test-resource     src/integration-test/resources     

9. Kesimpulannya

Artikel ini menggunakan Maven untuk menjalankan ujian integrasi dengan pelayan Jetty, yang memfokuskan pada konfigurasi plugin Maven surefire dan failafe .

Kod sumber lengkap untuk tutorial ini boleh didapati di GitHub.