Comment utiliser mockito pour tester un service REST?

OK. Ainsi, le contrat de la méthode est le suivant: Analyser la chaîne d'entrée en JSON, et l'envoi de BAD_REQUEST si elle est invalide. Si c'est valide, créer une entité dans le datastore avec des propriétés différentes (vous les connaissez), et renvoyer les OK.

Et vous avez besoin de vérifier que le contrat est rempli par la méthode.

Où Mockito de l'aide ici? Eh bien, si vous testez cette méthode sans Mockito, vous avez besoin d'un réel DataStoreService, et vous devez vérifier que l'entité a été créée correctement dans cette véritable DataStoreService. C'est là que votre test n'est pas une unité de test plus, et c'est aussi là que c'est trop complexe pour tester, trop long et trop dur à gérer, car il a besoin d'un environnement complexe.

Mockito pouvez nous aider en se moquant de la dépendance sur la DataStoreService: vous pouvez créer une maquette de DataStoreService, et de vérifier que cette maquette est en effet appelé à l'entité appropriée argument lorsque vous appelez votre initialize() méthode dans votre test.

Pour ce faire, vous devez être en mesure d'injecter le DataStoreService dans votre objet sous test. Il peut être aussi facile que la refactorisation de votre objet de la manière suivante:

public class MyRestService {
    private DataStoreService dataStoreService;

    //constructor used on the server
    public MyRestService() {
        this.dataStoreService = DatastoreServiceFactory.getDatastoreService();
    }

    //constructor used by the unit tests
    public MyRestService(DataStoreService dataStoreService) {
        this.dataStoreService = dataStoreService;
    }

    public Response initialize(String DatabaseSchema) {
         ...
         //use this.dataStoreService instead of datastore
    }
}

Et maintenant dans votre méthode de test, vous pouvez faire:

@Test
public void testInitializeWithGoodInput() {
    DataStoreService mockDataStoreService = mock(DataStoreService.class);
    MyRestService service = new MyRestService(mockDataStoreService);
    String goodInput = "...";
    Response response = service.initialize(goodInput);
    assertEquals(Response.Status.OK, response.getStatus());

    ArgumentCaptor<Entity> argument = ArgumentCaptor.forClass(Entity.class);
    verify(mock).put(argument.capture());
    assertEquals("the correct kind", argument.getValue().getKind());
    //... other assertions
}

Mockito est (généralement) pour les tests portions de code; par exemple si vous souhaitez utiliser votre service de REPOS, mais ne veulent pas faire un full-stack de test, vous me moquer de la service de qui est connecté au RESTE du service, vous permettant précisément, et de façon constante, test de comportement spécifique.

De test interne des parties du RESTE du service (par exemple, un service spécifique de la méthode), sans frapper une base de données, vous me moquer de la DB sous-système, permettant de test de service internes uniquement, sans participation de la DB. Ce test appartient dans le RESTE module de service, et non du côté client.

Pour tester le RESTE du service que vous souhaitez utiliser un client actuel de la bibliothèque, la création d'une pile de test d'intégration. Mockito pourrait être utilisé ici pour se moquer de portions du client sans rapport avec le REPOS, la consommation de services.

Je suis d'accord ce n'est pas l'unité de test, mais test d'intégration, de toute façon vous préférez prendre un coup d'oeil sur le jersey et intégré grizzly serveur de tests. Pour summ vers le haut, ce code commence le grizzly serveur (qui pourrait commencer à la datbase ainsi) à localhost:8888, puis le programme d'installation du client jersey client et envoyé un POST de demande d'intervention doit être testé. C'est une intégration puisque vous êtes les tests à la fois de serveur et de base de données, vous pouvez utiliser mockito pour émuler la base de données, cependant, mais cela dépend de comment lié à votre serveur de base de données et sont.

(test à l'aide de jersey 1.11 et grizzly 2.2)

    @BeforeClass
    public static void setUpClass() throws Exception {
        //starts grizzly
        Starter.start_grizzly(true);
        Thread.sleep(4000);
    }

    @Before
    public void setUp() throws Exception {
        client = new Client();
        webResource = client.resource("http://localhost:8888");
    }   

    @Test
    public void testPostSchemaDatabase() throws Exception {
        {
            String DatabaseSchema = "{ database_schema : {...}}";
            logger.info("REST client configured to send: "  + DatabaseSchema);
            ClientResponse response =  
                    webResource
                             .path("/initialize")
                             .type("application/json")
                             .post(ClientResponse.class, DatabaseSchema);
            //wait for the server to process
            Thread.sleep(2000);
            assertEquals(response.getStatus(), 204);    
            //test the response
        }       
    }

    @After
    public void after() throws JSONException
    {
            //probably you want to delete the schema at database and stop the server

}