इकाई परीक्षण संग्रह का सबसे अच्छा तरीका?

Question

मैं सोच रहा हूं कि लोग कैसे यूनिट परीक्षण करते हैं और जोर देते हैं कि "अपेक्षित" संग्रह "वास्तविक" संग्रह के समान/समान है (ऑर्डर महत्वपूर्ण नहीं है)।

इस दावे करने के लिए, मैं अपने सरल ज़ोर एपीआई लिखा है: -

public void assertCollection(Collection<?> expectedCollection, Collection<?> actualCollection) { 
    assertNotNull(expectedCollection); 
    assertNotNull(actualCollection); 
    assertEquals(expectedCollection.size(), actualCollection.size()); 
    assertTrue(expectedCollection.containsAll(actualCollection)); 
    assertTrue(actualCollection.containsAll(expectedCollection)); 
} 

खैर, यह काम करता है। यह बहुत आसान है अगर मैं केवल इंटीजर या स्ट्रिंग्स का गुच्छा लगा रहा हूं। अगर मैं हाइबरनेट डोमेन का संग्रह करने की कोशिश कर रहा हूं, तो यह भी बहुत दर्दनाक हो सकता है, उदाहरण के लिए कहें। संग्रह.containsAll (..) चेक करने के लिए बराबर (..) पर निर्भर करता है, लेकिन मैं हमेशा अपने हाइबरनेट डोमेन में बराबर (..) को ओवरराइड करता हूं ताकि केवल व्यवसाय कुंजी जांच सकें (जो कि सबसे अच्छा अभ्यास है हाइबरनेट वेबसाइट) और उस डोमेन के सभी फ़ील्ड नहीं। निश्चित रूप से, यह केवल व्यवसाय कुंजी के खिलाफ जांच करना समझ में आता है, लेकिन कई बार मैं वास्तव में यह सुनिश्चित करना चाहता हूं कि सभी फ़ील्ड सही हैं, न केवल व्यवसाय कुंजी (उदाहरण के लिए, नया डेटा एंट्री रिकॉर्ड)। तो, इस मामले में, मैं domain.equals (..) के साथ गड़बड़ नहीं कर सकता और ऐसा लगता है कि मुझे कुछ compators को केवल compution.contains पर निर्भर करने के बजाय इकाई परीक्षण उद्देश्यों के लिए लागू करने की आवश्यकता है। (सभी)।

क्या कुछ परीक्षण पुस्तकालय मैं यहां लाभ उठा सकते हैं? आप अपने संग्रह का परीक्षण कैसे करते हैं?

धन्यवाद।

Answer 1

यदि बराबर विधि सभी फ़ील्ड की जांच नहीं करती है, तो आप यूनिटिल http://unitils.org/ReflectionAssert कक्षा का उपयोग कर सकते हैं। कॉलिंग

ReflectionAssert.assertReflectionEquals(expectedCollection,actualCollection) 

क्षेत्र द्वारा प्रत्येक तत्व संजीदगी से क्षेत्र की तुलना करेंगे (और यह सिर्फ संग्रहों के लिए लागू नहीं होता है, यह किसी भी वस्तु के लिए काम करेंगे)।

Answer 2

मुझे यकीन नहीं है कि आप जिस जुनीट का उपयोग कर रहे हैं, लेकिन हाल के लोगों में assertThat विधि है जो एक तर्क के रूप में Hamcrest Matcher लेता है। वे composable हैं ताकि आप एक संग्रह के बारे में जटिल दावे का निर्माण कर सकते हैं।

उदाहरण के लिए, यदि आप का दावा करने की है कि एक संग्रह A संग्रह B में हर तत्व निहित चाहता था, आप लिख सकते हैं:

import static org.junit.Assert.*; 
import static org.junit.matchers.JUnitMatchers.*; 
import static org.hamcrest.core.IsCollectionContaining.*; 
import static org.hamcrest.collection.IsCollectionWithSize.*; 
import org.hamcrest.beans.SamePropertyValuesAs; 

public class CollectionTests { 

    /* 
    * Tests that a contains every element in b (using the equals() 
    * method of each element) and that a has the same size as b. 
    */ 
    @Test 
    public void test() { 
     Collection<Foo> a = doSomething(); 
     Collection<Foo> b = expectedAnswer; 

     assertThat(a, both(hasItems(b)).and(hasSize(b.size()))); 
    } 

    /* 
    * Tests that a contains every element in b (using introspection 
    * to compare bean properties) and that a has the same size as b. 
    */ 
    @Test 
    public void testBeans() { 
     Collection<Foo> a = doSomething(); 
     Collection<Foo> b = expectedAnswer; 
     Collection<Matcher<Foo>> bBeanMatchers = 
      new LinkedList<Matcher<Foo>>(); 

     // create a matcher that checks for the property values of each Foo 
     for(Foo foo: B) 
      bBeanMatchers.add(new SamePropertyValuesAs(foo)); 

     assertThat(a, both(hasItems(bBeanMatchers)).and(hasSize(b.size()))) 
    } 
} 

पहले टेस्ट बस हर वस्तु पर equalTo() मिलान का उपयोग करता है (जो होगा आपके बराबर कार्यान्वयन के लिए प्रतिनिधि)। यदि यह पर्याप्त मजबूत नहीं है, तो आप दूसरे मामले का उपयोग कर सकते हैं, जो प्रत्येक तत्व की तुलना करने के लिए गेटर्स और सेटर्स का उपयोग करेगा। अंत में, आप अपने खुद के मैचर्स भी लिख सकते हैं। Hamcrest पैकेज फ़ील्ड से मिलान करने के लिए एक matcher के साथ नहीं आता है (मिलान बीन गुणों के विपरीत), लेकिन फील्डमैचर लिखना मुश्किल है (और वास्तव में एक अच्छा अभ्यास है)।

मैचर्स पहले थोड़ा अजीब हैं, लेकिन यदि आप नए मैचर्स बनाने के उनके उदाहरण का पालन करते हैं तो एक स्थिर विधि है जो मैचर लौटाती है, आप import static एस का एक गुच्छा कर सकते हैं और आपका कोड मूल रूप से अंग्रेजी वाक्य की तरह पढ़ता है (" जोर देकर कहते हैं कि दोनों में बी में आइटम हैं और बी के समान आकार है ")। आप इन चीजों के साथ एक सुंदर प्रभावशाली डीएसएल बना सकते हैं और अपना टेस्ट कोड बहुत अधिक सुरुचिपूर्ण बना सकते हैं।

Answer 3

मुझे काम करने के लिए jasonmp85's answer का अंतिम भाग नहीं मिला। मैंने आयात किए गए आयातों को शामिल किया क्योंकि कुछ जूनिट जारों में सुविधा के लिए पुरानी हामक्रिस्ट सामग्री शामिल है। यह मेरे लिए काम करता है, लेकिन जोरदार लूप निश्चित रूप से उतना अच्छा नहीं है जितना hasItems(..) जेसन के उत्तर में लिखा गया है।

import org.hamcrest.Matcher; 
import org.hamcrest.beans.SamePropertyValuesAs; 
import org.hamcrest.collection.IsCollectionWithSize; 

import static org.hamcrest.CoreMatchers.hasItem; 
import static org.hamcrest.MatcherAssert.assertThat; 

... 

/* 
* Tests that a contains every element in b (using introspection 
* to compare bean properties) and that a has the same size as b. 
*/ 
@Test 
public void testBeans() { 
    Collection<Foo> a = doSomething(); 
    Collection<Foo> b = expectedAnswer; 
    Collection<Matcher<Foo>> bBeanMatchers = new LinkedList<Matcher<Foo>>(); 

    // create a matcher that checks for the property values of each Foo 
    for(Foo foo: B) 
     bBeanMatchers.add(new SamePropertyValuesAs(foo)); 

    // check that each matcher matches something in the list 
    for (Matcher<Foo> mf : bBeanMatchers) 
     assertThat(a, hasItem(mf)); 

    // check that list sizes match 
    assertThat(a, IsCollectionWithSize.hasSize(b.size())); 
} 

... 

Answer 4

एक अन्य विकल्प यदि आप अपने संग्रह का निर्माण नहीं किया है:

import static org.hamcrest.MatcherAssert.assertThat; 
import static org.hamcrest.Matchers.contains; 
import static org.hamcrest.Matchers.allOf; 
import static org.hamcrest.beans.HasPropertyWithValue.hasProperty; 
import static org.hamcrest.Matchers.is; 

@Test 
@SuppressWarnings("unchecked") 
public void test_returnsList(){ 

    arrange(); 

    List<MyBean> myList = act(); 

    assertThat(myList , contains(allOf(hasProperty("id",   is(7L)), 
             hasProperty("name",  is("testName1")), 
             hasProperty("description", is("testDesc1"))), 
           allOf(hasProperty("id",   is(11L)), 
             hasProperty("name",  is("testName2")), 
             hasProperty("description", is("testDesc2"))))); 
} 

उपयोग containsInAnyOrder अगर आप वस्तुओं के आदेश की जांच नहीं करना चाहती।

पीएस Suppresed चेतावनी से बचने के लिए कोई मदद वास्तव में सराहना की जाएगी।