Mockito विधि कॉल के आदेश / अनुक्रम को सत्यापित करता है

Question

क्या यह सत्यापित करने का कोई तरीका है कि क्या मॉकिटो में methodOneपहले कहा जाता है methodTwo?

public class ServiceClassA {
    public void methodOne(){}
 }

public class ServiceClassB {
    public void methodTwo(){}
 }

---

public class TestClass {
    public void method(){
        ServiceClassA serviceA = new ServiceClassA();
        ServiceClassB serviceB = new ServiceClassB();
        serviceA.methodOne();
        serviceB.methodTwo();
    }
}

Answer 1

InOrder ऐसा करने में आपकी मदद करता है।

ServiceClassA firstMock = mock(ServiceClassA.class);
ServiceClassB secondMock = mock(ServiceClassB.class);

Mockito.doNothing().when(firstMock).methodOne();   
Mockito.doNothing().when(secondMock).methodTwo();  

//create inOrder object passing any mocks that need to be verified in order
InOrder inOrder = inOrder(firstMock, secondMock);

//following will make sure that firstMock was called before secondMock
inOrder.verify(firstMock).methodOne();
inOrder.verify(secondMock).methodTwo();

Comments

यह सही है, हालांकि अन्य स्टबिंग के लिए प्लेसहोल्डर के अलावा कॉल करने के लिए कॉल करने की आवश्यकता नहीं है। Mockito चुपचाप शून्य विधि कॉल को डिफ़ॉल्ट रूप से स्वीकार करेगा।

— जेफ बोमेन

यह उन्हें स्वीकार करता है जबकि वस्तु की कोई निर्भरता नहीं है यदि वस्तु पर निर्भरता है तो एक अपवाद होगा =)

— कोइटो

inOrder.verifyNoMoreInteractions();इस उदाहरण में अंतिम सत्यापन के बाद यह सत्यापित करने के लिए विचार करें कि कोई अन्य कॉल नहीं किया गया था।

— ड्वेन

बस स्पष्ट करने के लिए: यह सत्यापित करने से ठीक पहले ऑडर को परिभाषित करना सुरक्षित है - मॉक पर कुछ (परीक्षण किए गए) तरीकों को लागू करने के बाद।

— user3078523

क्या परिणाम inOrder(firstMock, secondMock)और के लिए समान हैं inOrder(secondMock, firstMock)? शायद आप इस बारे में एक नोट बनाने के लिए जवाब अपडेट कर सकते हैं।

— केविनरपे

Answer 2

ध्यान दें कि आप इनऑर्डर श्रेणी का उपयोग यह सत्यापित करने के लिए भी कर सकते हैं कि विभिन्न तरीकों को एक मॉक पर क्रम में बुलाया जाता है, न कि केवल दो या अधिक मॉक पर।

मान लीजिए कि मेरे दो वर्ग हैं Fooऔर Bar:

public class Foo {
  public void first() {}
  public void second() {}
}

public class Bar {
  public void firstThenSecond(Foo foo) {
    foo.first();
    foo.second();
  }
}

मैं तो यह है कि परीक्षण के लिए एक परीक्षण वर्ग में जोड़ सकते हैं Barकी firstThenSecond()विधि वास्तव में कॉल first(), तो second()नहीं है, और second(), फिर first()। निम्नलिखित परीक्षण कोड देखें:

public class BarTest {
  @Test
  public void testFirstThenSecond() {
    Bar bar = new Bar();
    Foo mockFoo = Mockito.mock(Foo.class);
    bar.firstThenSecond(mockFoo);

    InOrder orderVerifier = Mockito.inOrder(mockFoo);
    // These lines will PASS
    orderVerifier.verify(mockFoo).first();
    orderVerifier.verify(mockFoo).second();

    // These lines will FAIL
    // orderVerifier.verify(mockFoo).second();
    // orderVerifier.verify(mockFoo).first();
  }
}

Comments

यह स्वीकृत उत्तर पर एक टिप्पणी होनी चाहिए थी, न कि एक नया उत्तर।

— ACH

मैं आपकी टिप्पणी से असहमत हूं @ach कोड नमूना मदद करता है, इसलिए एक नया उत्तर समझ में आता है।

— स्नेक

क्या एक ही विधि को सत्यापित करने का एक तरीका दो बार कहा जाता है, लेकिन में पारित मापदंडों के क्रम को सत्यापित करें? उदा फर्स्ट find('foo'), फिरfind('bar')

— स्नेक

ऐसा लगता है कि मेरा जवाब stackoverflow.com/questions/36573399/…

— Snekse

यह वास्तव में स्वीकृत उत्तर की तुलना में एक बेहतर उदाहरण है क्योंकि यह तुलना में अधिक विशिष्ट उपयोग दिखाता हैdoNothing()

— आर्किमिडीज ट्रेजानो

Answer 3

हाँ, यह प्रलेखन में वर्णित है। आपको InOrder वर्ग का उपयोग करना होगा ।

उदाहरण (पहले से निर्मित दो मोक्स मानकर):

InOrder inOrder = inOrder(serviceAMock, serviceBMock);

inOrder.verify(serviceAMock).methodOne();
inOrder.verify(serviceBMock).methodTwo();

Answer 4

BDD के साथ

@Test
public void testOrderWithBDD() {


    // Given
    ServiceClassA firstMock = mock(ServiceClassA.class);
    ServiceClassB secondMock = mock(ServiceClassB.class);

    //create inOrder object passing any mocks that need to be verified in order
    InOrder inOrder = inOrder(firstMock, secondMock);

    willDoNothing().given(firstMock).methodOne();
    willDoNothing().given(secondMock).methodTwo();

    // When
    firstMock.methodOne();
    secondMock.methodTwo();

    // Then
    then(firstMock).should(inOrder).methodOne();
    then(secondMock).should(inOrder).methodTwo();


}