Wie in-memory-unit-test-Spring-Jersey

Ich arbeite mit Spring-Jersey3 und kann nicht herausfinden, wie man unit-test-die RESTFul API mit Spring beans

Controller

package com.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.service.DataSource;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("test")
@Component
public class SpringController {
    @Autowired
    private DataSource datasource;

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getHello() {
        return new String(datasource.load());
    }
}

Service-Schnittstelle

package com.service;

public interface DataSource {
    public String load();
}

Service-Implementierung

package com.service;

import org.springframework.stereotype.Repository;

@Repository
public class DataSourceImpl implements DataSource {

    @Override
    public String load() {
        return "Hello";
    }
}

ResourceRegister.java (Jersey Ressource registrieren)

package com.component;

import org.glassfish.jersey.server.ResourceConfig;
import com.controller.SpringController;

public class ResourceRegister extends ResourceConfig {

    public ResourceRegister () {
        register(SpringController.class);
    }
}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">

<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:applicationContext.xml</param-value>
</context-param>

<servlet>
  <servlet-name>Jersey</servlet-name>
  <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
<init-param>
  <param-name>javax.ws.rs.Application</param-name>
  <param-value>com.component.ResourceRegister</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>Jersey</servlet-name>
  <url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>

serviceContext.xml (Anwendungskontext)

<?xml version="1.0" encoding="UTF-8"?>

<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scan base-package="com.service" />
<context:component-scan base-package="com.controller" />

</beans>

Unit-test - <<-- ich habe wirklich keine Ahnung, wie um dies zu testen

public class test extends JerseyTest {
    public test() {
        super("com.service", "com.controller");
    }

    @Override
    protected AppDescriptor configure() {
        return new WebAppDescriptor.Builder("com.service","com.controller")
               .contextParam("contextConfigLocation", "classpath:serviceContext.xml")
               .contextPath("/rest")
               .servletClass("org.glassfish.jersey.servlet.ServletContainer.class")
               .initParam("javax.ws.rs.Application", "com.component.ResourceRegister")
               .build();
    }

    @Test
    public void test() {
        Client client = new Client();
        WebResource resource = client.resource("test");

        ClientResponse response = resource.post(ClientResponse.class);

        assertEquals(200, resposne.getStatus());
    }
}

Projekt Source Code

Problem : Dependency injection gibt null zurück,

InformationsquelleAutor stackoverflow | 2015-02-19

14

Ein paar Dinge, die ich beheben würde:
- Verwendung Jersey 1.x aromatisierten Trikot-Test-Framework, aber Ihre Anwendung ist Jersey 2.x. Siehe unten für 2.x Abhängigkeit.
- Ich habe noch nie verwendet die Jersey 1.x aromatisierten Test-Framework, aber mit Trikot 2.x, die In-Memory-container nicht unterstützt servlet-abhängige features. Siehe unten für verschiedene Abhängigkeit.
- Jersey mit Test-Framework, die Sie nicht brauchen, um das Client selbst. Es gibt eine erstellt, und wir können uns einfach anrufen JerseyTest's target(String path) Methode, um wieder ein WebTarget (Trikot 2.x, WebResource ist Jersey 1.x)
Hier ist ein Refactoring, das funktioniert.

Abhängigkeit (die ich nur Hinzugefügt, diese Abhängigkeit, und nicht alles, was aus, wie Ihr GitHub-Projekt nicht alles sein, test verwandt, wie dein code-Beispiel oben hat)
```
<dependency>
    <groupId>org.glassfish.jersey.test-framework.providers</groupId>
    <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
    <version>2.15</version>
</dependency>
```
Test
```
import com.component.ResourceRegister;
import org.glassfish.jersey.servlet.ServletContainer;
import org.glassfish.jersey.test.DeploymentContext;
import org.glassfish.jersey.test.JerseyTest;
import org.glassfish.jersey.test.ServletDeploymentContext;
import org.glassfish.jersey.test.grizzly.GrizzlyWebTestContainerFactory;
import org.glassfish.jersey.test.spi.TestContainerFactory;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.web.context.ContextLoaderListener;

public class SpringTest extends JerseyTest {

    @Override
    protected TestContainerFactory getTestContainerFactory() {
        return new GrizzlyWebTestContainerFactory();
    }

    @Override
    protected DeploymentContext configureDeployment(){
        return ServletDeploymentContext
                .forServlet(new ServletContainer(new ResourceRegister()))
                .addListener(ContextLoaderListener.class)
                .contextParam("contextConfigLocation", "classpath:applicationContext.xml")
                .build();
    }

    @Test
    public void test() {
        String response = target("test").request().get(String.class);
        Assert.assertEquals("Hello", response);
        System.out.println(response);
    }  
}
```
Für diejenigen, die nicht in einem xml-Kontext-Datei, Sie können eine annotation-config-Anwendung Kontext, und fügen Sie es als ein init-param
```
return ServletDeploymentContext
        .forServlet(new ServletContainer(new ResourceRegister()))
        .addListener(ContextLoaderListener.class)
        .initParam("contextConfig", new AnnotationConfigApplicationContext(YourSpringConfig.class))
        .build();
```
Andere Ressourcen:
- Trikot-Test-Framework-Dokumentation
- Weitere Beispiele aus dem Test-Framework source code tests. (Hinweis: der link, den ich angegeben habe ist für grizzly-web-container Beispiele, aber wenn Sie die traverse zurück zum Anbieter, Sie können sich bei jedem Anbieter und gehen Sie auf die test-Pakete Beispiele für solche Anbieter)
UPDATE

So nach ein paar mehr testen, hier sind ein paar interessante Dinge, die ich entdeckt

Ein:

Mit den oben genannten Abhängigkeit, auch wenn wir nicht so konfigurieren, das DeploymentContext, und nur überschreiben Application configure() im JerseyTest es wird immer noch funktionieren. Kann nicht wirklich erklären, aber es scheint, dass der Deskriptor wird noch abgeholt.
```
import javax.ws.rs.core.Application;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.Assert;
import org.junit.Test;

public class SpringTest extends JerseyTest {

    @Override
    public Application configure() {
        return new ResourceConfig().packages("com.controller");
    }

    @Test
    public void test() {
        String response = target("test").request().get(String.class);
        Assert.assertEquals("Hello", response);
        System.out.println(response);
    }  
}
```
Zwei:

Selbst wenn wir das loswerden der oben genannten Abhängigkeit (grizzly) und die Nutzung der in-memory-Abhängigkeit, die gleiche, einfache früheren test funktioniert. Die Dokumentation besagt

In-Memory Containers ist nicht eine echte container. Es beginnt Jersey-Anwendung und direkt Anrufe interne APIs zu handhaben Anfrage erstellt durch AUFTRAGGEBER zur Verfügung gestellt von test-Frameworks. Es gibt keine Netzwerk-Kommunikation beteiligt. Diese Container nicht unterstützt servlet und andere container-abhängigen Funktionen, aber es ist eine perfekte Wahl für einfache unit-tests.

So, ich bin nicht ganz sicher, was Servlet-Funktionen, die Sie sich beziehen, wie dieser test funktioniert immer noch
```
<dependency>
    <groupId>org.glassfish.jersey.test-framework.providers</groupId>
    <artifactId>jersey-test-framework-provider-inmemory</artifactId>
    <version>2.15</version>
</dependency>
```
Was ich nicht verstehe, insbesondere ist diese Aussage

"Es gibt keinen Netzwerk-Kommunikation beteiligten"

weil wenn ich den test sehe ich eine log -

INFO: Creating InMemoryTestContainer configured at the base URI http://localhost:9998/
- So versuche ich herauszufinden, wo dieser überschriebenen Methode kommt aus DeploymentContext configureDeployment(). Hab ich stieß mehrere version von JerseyTest Rahmen und kann nicht finden, wo diese Methode kommt aus
- Ich würde, loszuwerden, alle die Jersey zugehörigen Abhängigkeiten, die nicht org.glassfish.jersey. Meine Vermutung ist, Sie sind immer noch mit der älteren JerseyTest die nicht über diese Methode.
- Gut gemacht, sir. Ein sehr aufrichtiges danke.
- Und ich Stimme zu - das Test-framework hat einige verrückte Magie hinter den kulissen
InformationsquelleAutor Paul Samsotha

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

UPDATE

Ein:

Zwei: