Comment envoyer un objet maquette en tant que JSON dans mockmvc

Je veux envoyer un objet fantaisie dans le contrôleur via MockMvc avec un type de contenu JSON. Mais quand je suis en train de sérialiser la simulation de l'erreur est:

java.lang.UnsupportedOperationException: Expecting parameterized type, got interface org.mockito.internal.MockitoInvocationHandler.
 Are you missing the use of TypeToken idiom?

Mon code est comme suit:

@Test
public void testSomething(){

    String xyz = "";
    Integer i = 10;
    SomeClass inst = mock(SomeClass.class, withSettings().serializable());
    when(inst.getProperty1()).then(xyz);
    when(inst.getProperty2()).then(i);

    Gson gson = new Gson();
    String json = gson.toJson(inst); //this is creating error

    this.mockmvc.perform(put("/someUrl/").contentType(MediaType.JSON).content(json)).andExpect(status().isOk());
}

Quelqu'un peut me dire ce que je suis absent?

source d'informationauteur Sourabh

Je vous propose de créer un stub de votre SomeClass qui renvoie des valeurs connues de la getProperty1() et getProperty2() méthode. Selon la façon dont SomeClass est mis en œuvre, vous pouvez soit en créer un new instance directement, sous-classe et de redéfinir certaines méthodes, créer un anonyme intérieur de la classe si c'est une interface, etc.

@Test
public void testSomething(){

    String xyz = "";
    Integer i = 10;

    //alt 1:
    SomeClass stub = new SomeClass(xyz, i);

    //alt 2: 
    SomeClass stub = new StubSomeClass(xyz, i); //StubSomeClass extends SomeClass

    //alt 3: 
    SomeClass stub = new SomeClass() {
         @Override
         String getProperty1() {
             return xyz;
         }
         @Override
         Integer getProperty2() {
             return i;
         }
    }

    Gson gson = new Gson();
    String json = gson.toJson(stub);

    this.mockmvc.perform(put("/someUrl/")
        .contentType(MediaType.APPLICATION_JSON).content(json))
        .andExpect(status().isOk());
}

6

Même si c'était possible, la présentation d'un objet fantaisie à un JSON convertisseur de supposer une unité de test dédié à cette opération : la maquette d'un objet peut avoir plusieurs attributs et des méthodes, bien au-delà du réel de la classe et de la sérialisation pourrait conduire à une vraiment étrange résultat.

À mon humble avis, que c'est une unité de test, vous devez écrire à la main le json Chaîne sérialisée. Et vous pouvez faire d'autres tests si vous avez besoin de contrôler la façon dont Gson la sérialisation
1

J'ai trouver un moyen pour sérialiser un objet fantaisie dans un manière suivante:
```
Gson gson = new GSon();
String json = gson.toJson(mockedObject, mockedObjectType.class);
```
Bien que ce que j'ai essayé était INUTILE de cas depuis json sera dépouillé de toutes les moqueries que j'ai fournis dans la fonction test() ainsi, lorsque l'objet sera reconstruit, il n'aura pas de valeur de se moquer d'elle et va jeter NullPointerException lors de la première instance de l'utilisation de toute fonction ou de la propriété.

EDIT : Si vous voulez sérialiser les valeurs null il y a une fonction pour ça aussi :
```
Gson gson = new GsonBuilder().serializeNulls().create();
```

Nous avons eu un problème similaire:
il a été la journalisation de l'instruction pour la sortie d'un objet sérialisé en json. Et de l'unité de test pour ce produit un message d'erreur parce que gson ne pouvais pas sérialiser un objet fantaisie.
Il a été résolu à la fourniture de l'exclusion de la stratégie qui ignore la sérialisation de la Classe et les champs de type Classe:

 private final Gson gson = new GsonBuilder()
     .setExclusionStrategies(new ExclusionStrategy() {
    @Override
    public boolean shouldSkipClass(Class<?> clazz) {
        return clazz instanceof Class;
    }

    @Override
    public boolean shouldSkipField(FieldAttributes field) {
        return field.getDeclaredClass() == Class.class;
    }
}).create();

Dans la configuration de test, vous pouvez envelopper de message par défaut du convertisseur avec un autre message convertisseur qui prend en charge la sérialisation d'un objet en Chaîne de caractères.

package com.example;
import org.apache.commons.io.IOUtils;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import java.io.IOException;
import java.util.Arrays;
public class MockObjectHttpMessageConverter extends AbstractHttpMessageConverter {
private final AbstractHttpMessageConverter primaryConverter;
public MockObjectHttpMessageConverter(AbstractHttpMessageConverter primaryConverter) {
this.primaryConverter = primaryConverter;
setSupportedMediaTypes(Arrays.asList(MediaType.ALL));
}
@Override
protected boolean supports(Class clazz) {
return true;
}
@Override
protected Object readInternal(Class clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
throw new UnsupportedOperationException();
}
@Override
protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
try {
primaryConverter.write(o, MediaType.ALL, outputMessage);
} catch (Exception e) {
IOUtils.write(o.toString(), outputMessage.getBody());
}
}
}

Au Printemps du contexte XML:

<mvc:message-converters>
<bean class="com.example.MockObjectHttpMessageConverter">
<constructor-arg>
<bean class="org.springframework.http.converter.json.GsonHttpMessageConverter">
<property name="gson">
<bean class="com.google.gson.Gson" factory-bean="gsonBuilder" factory-method="create"/>
</property>
</bean>
</constructor-arg>
</bean>
</mvc:message-converters>

Vous devez vous connecter pour publier un commentaire.