दो JSONs

Question

की तुलना करते समय विशिष्ट नोड्स/विशेषताओं को अनदेखा करें, मैं दो JSON तारों की तुलना करना चाहता हूं जो एक विशाल पदानुक्रम है और यह जानना चाहते हैं कि वे मूल्यों में कहां भिन्न हैं। लेकिन रनटाइम पर कुछ मान उत्पन्न होते हैं और गतिशील होते हैं। मैं अपनी तुलना से उन विशेष नोड्स को अनदेखा करना चाहता हूं।

मैं वर्तमान में तुलना करने के लिए org.SkyScreamer से JSONAssert का उपयोग कर रहा हूं। यह मुझे अच्छा कंसोल आउटपुट देता है लेकिन किसी भी विशेषताओं को अनदेखा नहीं करता है।

पूर्व के लिए।

java.lang.AssertionError messageHeader.sentTime 
expected:null 
got:09082016 18:49:41.123 

अब यह गतिशील आता है और इसे अनदेखा किया जाना चाहिए। जैसे

JSONAssert.assertEquals(expectedJSONString, actualJSONString,JSONCompareMode, *list of attributes to be ignored*) 

कुछ यह बहुत अच्छा कोई JSONAssert में एक समाधान का सुझाव है, तो हो सकता है। हालांकि अन्य तरीकों का भी स्वागत है।

Answer 1

आप इसके लिए अनुकूलन का उपयोग कर सकते हैं। उदाहरण के लिए, एक उच्च-स्तरीय विशेषता "टाइमस्टैम्प" उपयोग नामित अनदेखी करने के लिए अगर आप की जरूरत है:

JSONAssert.assertEquals(expectedResponseBody, responseBody, 
      new CustomComparator(JSONCompareMode.LENIENT, 
       new Customization("timestamp", (o1, o2) -> true))); 

यह भी "entry.id" की तरह पथ एक्सप्रेशन का उपयोग करना संभव है। अपने अनुकूलन में आप दो मानों की तुलना करने के लिए जो भी तरीका पसंद करते हैं उसका उपयोग कर सकते हैं। ऊपर दिया गया उदाहरण हमेशा सत्य देता है, इससे कोई फर्क नहीं पड़ता कि अपेक्षित मूल्य और वास्तविक मूल्य क्या है। यदि आपको आवश्यकता हो तो आप वहां अधिक जटिल चीजें कर सकते हैं।

Answer 2

सबसे पहले इसके लिए open issue है।

मेरी परीक्षणों में मैं क्रमबद्धता/अक्रमांकन के लिए JsonUtil वर्ग की मदद से वास्तविक वस्तु के साथ नियंत्रक से json तुलना:

public static <T> String writeIgnoreProps(T obj, String... ignoreProps) { 
    try { 
     Map<String, Object> map = getMapper().convertValue(obj, new TypeReference<Map<String, Object>>() {}); 
     for (String prop : ignoreProps) { 
      map.remove(prop); 
     } 
     return getMapper().writeValueAsString(map); 
    } catch (JsonProcessingException e) { 
     throw new IllegalStateException("Invalid write to JSON:\n'" + obj + "'", e); 
    } 
} 

:

public class JsonUtil { 
    public static <T> List<T> readValues(String json, Class<T> clazz) { 
     ObjectReader reader = getMapper().readerFor(clazz); 
     try { 
      return reader.<T>readValues(json).readAll(); 
     } catch (IOException e) { 
      throw new IllegalArgumentException("Invalid read array from JSON:\n'" + json + "'", e); 
     } 
    } 

    public static <T> T readValue(String json, Class<T> clazz) { 
     try { 
      return getMapper().readValue(json, clazz); 
     } catch (IOException e) { 
      throw new IllegalArgumentException("Invalid read from JSON:\n'" + json + "'", e); 
     } 
    } 

    public static <T> String writeValue(T obj) { 
     try { 
      return getMapper().writeValueAsString(obj); 
     } catch (JsonProcessingException e) { 
      throw new IllegalStateException("Invalid write to JSON:\n'" + obj + "'", e); 
     } 
    } 

विशिष्ट वस्तु क्षेत्र मैं नई विधि को जोड़ने है की अनदेखी करने के लिए

और परीक्षण में मेरा जोर अब इस तरह दिखता है:

  mockMvc.perform(get(REST_URL)) 
      .andExpect(status().isOk()) 
      .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) 
      .andExpect(content().json(JsonUtil.writeIgnoreProps(USER, "registered"))) 

Answer 3

आप JsonUnit का उपयोग कर सकते हैं इसमें यह कार्यक्षमता है जिसे आप ढूंढ रहे हैं हम खेतों, पथों और मूल्यों को अनदेखा कर सकते हैं आदि। अधिक जानकारी के लिए इसे देखें। उदाहरण के लिए, आप कभी कभी आप तुलना करते समय निश्चित मूल्यों की अनदेखी करने की जरूरत है इस

assertJsonEquals(
    "{\"root\":{\"test\":1, \"ignored\": 2}}", 
    "{\"root\":{\"test\":1, \"ignored\": 1}}", 
    whenIgnoringPaths("root.ignored") 
); 

की तरह एक पथ की उपेक्षा कर सकते हैं। इस

assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}", 
    "{\n\"test\": {\"object\" : {\"another\" : 1}}}");