Java 如何在JSON转换上使用Mockito编写JUnit测试？

我有一个服务类，它使用DynamoDB将JSON从一种模式转换为另一种模式。 这个类有各种方法来操作JSON字段，如下所示。我得写JUnit 使用Mockito对此代码进行测试。 ConvertTopProviderJSON方法将来自第三方的一个JSON转换为预定义模板，以下方法正在处理转换后的JSON上的详细信息

我是JUnit&Mockito的新手，我该如何继续

```
@Service
public class ServiceClass {
    
    public String convertToProviderJson(String consumerString, String providerTemplateJson)
            throws JsonProcessingException {
        //create ObjectMapper instance
        ObjectMapper objectMapper = new ObjectMapper();

        //convert json file to map
        String currentFieldName = "";
        String currentTemplateKey = "";
        boolean templateMatchError = false;
        Map<?, ?> providerMap;
        Map<String, Object> providerOutputMap = new LinkedHashMap<>();
        System.out.println("Provider JSON");
        if(!UtilityClass.isJSONValid(consumerString)) {
            throw new MalformedJsonException("Incorrect Consumer Input JSON.");
        }

        if(!UtilityClass.isJSONValid(providerTemplateJson)) {
            throw new MalformedJsonException("Incorrect Provider Template JSON.");
        }
        try {
            JSONObject consumerJson = new JSONObject(consumerString);
            providerMap = objectMapper.readValue(providerTemplateJson, Map.class);

            //iterate over Provider Template map.
            for (Map.Entry<?, ?> entry : providerMap.entrySet()) {
                String key = (String) entry.getKey();
                currentTemplateKey = key;
                String value = (String) entry.getValue();
                Pattern p = Pattern.compile(TransformationConstants.TEMPLATE_FUNCTION_REGEX);

                Matcher matcher = p.matcher((CharSequence) entry.getValue());
                if (matcher.matches()) {
                    String[] splitString = value.split(LEFT_ROUND_BRACKET);
                    String functionName = splitString[0];
                    String fieldName = splitString[1].split(RIGHT_ROUND_BRACKET)[0];
                    currentFieldName = fieldName;
                    Object fieldValue = invokeFunction(consumerJson, functionName, fieldName);
                    providerOutputMap.put(key, fieldValue);
                } else {
                    templateMatchError = true;
                    break;
                }
            }

        } catch(JsonEOFException e) {
            throw new MalformedJsonException("Incorrect Provider Template JSON.");
        } catch (Exception e) {
            throw new MalformedJsonException("Field '" + currentFieldName + "' missing in input json.");
        }
        if(templateMatchError) {
            throw new MalformedJsonException("Value for Field '" + currentTemplateKey
                    + "' in template JSON is not in correct format.");
        }
        String outputJson = objectMapper.writeValueAsString(providerOutputMap);
        System.out.println("Provider JSON: " + outputJson);
        return outputJson;
    }

    private Object invokeFunction(JSONObject consumerJson, String functionName, String fieldName)
            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        TransformationService obj = new TransformationService();
        Method method;
        method = obj.getClass().getMethod(functionName, JSONObject.class, String.class);
        return method.invoke(obj, consumerJson, fieldName);
    }

    public Object getField(JSONObject jsonObject, String fieldName) throws JSONException {
        if(jsonObject.has(fieldName)) {
            return jsonObject.get(fieldName);
        }
        throw new MalformedJsonException("Field '" + fieldName + "' missing in input json.");
    }
}

@Test   
public void hasFieldTest() {
    JSONObject obj = new JSONObject();
    obj.put("id", "1");
    obj.put("name", "divyanka");
    when(((Object) transformationMock.getField(jsonObjmock, "name")).thenReturn(objectMock);
    JSONAssert.assertEquals("{id:1}", obj, 'strict':false);     
}

要测试（的

getField

方法）

ServiceClass

，我想：

import static org.junit.jupiter.api.Assertions.assertThrows;
// ...

class ServiceClassTest {

   //Object/Class under test:
   private ServiceClass testee = new ServiceClass(); // create new or "obtain somewhere" (like @Autowired in Spring testing...)

  //... test all methods, lines:

  @Test
  public void testGetFieldOK() {
      // prepare "good" object:
      JSONObject obj = new JSONObject();
      obj.put("foo", "bar");

      // TEST/invoke (!):
      Object result = testee.getField(obj, "foo");
     
     // assert (with your assertion framework/style):
     // result is not null AND result == "bar"  
     // done!
  }

  @Test
  public void testGetFieldException() {
      // prepare "bad" object:
      JSONObject obj = new JSONObject();

      // Test/Expect exception -> https://stackoverflow.com/a/40268447/592355 ->:
      MalformedJsonException thrown = assertThrows(
       MalformedJsonException.class,
       () -> testee.getField(obj, "foo"),
       "Expected getField(obj, \"foo\") to throw, but it didn't"
      );

      //assert on exception (message):
      assertTrue(thrown.getMessage().contains("Field 'foo' missing in input json.")); 

  }

  //create more tests like that... (-> coverage),
  //.. WHEN real parameters, associated objects and class (invocations) are not applicable, mock them!
}

Thx至：

并总结主要议题：

• 测试一个尽可能真实的物体
• （尝试）实现覆盖
• 与模拟相比，更喜欢“真实实现”，并且仅在真实实现不适用/成本太高时使用它们。（接口、外部代码/系统……内部代码/系统，“布线”成本太高/不适用，且包含在其他测试中。）

---

因此，在您的代码中：

ObjectMapper

和

TransformationService

看起来像是可能的模拟候选对象，但不值得，因为它们是在本地创建的（在测试方法中）

UtilityClass

也可以被（电源）嘲笑，但它值得吗！？？：-）

---

如果

UtilityClass

是一个（外部）生产（收费）API，您可能需要模拟它。

。当您测试此服务（类）时，您不应该模拟它。并且忘记了：您好，欢迎使用！：-）