मॉकिटो - यह सत्यापित करने के लिए कि एक नकली को कभी भी नहीं बुलाया गया था

Question

मैं मॉकिटो के साथ सत्यापित करने का एक तरीका ढूंढ रहा हूं, कि परीक्षण के दौरान दिए गए मॉक के साथ कोई बातचीत नहीं हुई थी। सत्यापन मोड never() के साथ किसी दिए गए विधि के लिए इसे प्राप्त करना आसान है, लेकिन मुझे अभी तक पूर्ण मॉक के लिए समाधान नहीं मिला है।

जो मैं वास्तव में प्राप्त करना चाहता हूं: परीक्षणों में सत्यापित करें, कि कंसोल पर कुछ भी मुद्रित नहीं होता है। JUnit साथ सामान्य विचार है कि प्रकार है:

private PrintStream systemOut; 

@Before 
public void setUp() { 
    // spy on System.out 
    systemOut = spy(System.out); 
} 

@After 
public void tearDown() { 
    verify(systemOut, never()); // <-- that doesn't work, just shows the intention 
} 

एक PrintStream तरीकों की टन है और मैं वास्तव में प्रत्येक सत्यापित करने के लिए नहीं करना चाहते हैं और अलग की पुष्टि के साथ हर एक - और System.err के लिए एक ही ...

तो मुझे आशा है कि, यदि कोई आसान समाधान है, तो मैं यह कर सकता हूं कि मेरे पास एक अच्छा परीक्षण कवरेज है, सॉफ़्टवेयर इंजीनियरों (और स्वयं) को अपने (मेरा) डीबग कोड को System.out.println("Breakpoint#1"); या e.printStacktrace(); जैसे परिवर्तन करने से पहले निकालने के लिए मजबूर करें।

Answer 1

इस का उपयोग करें:

इस समस्या के हल के लिए

import static org.mockito.Mockito.verifyZeroInteractions; 

// ... 

private PrintStream backup = System.out; 

@Before 
public void setUp() { 
    System.setOut(mock(PrintStream.class)); 
} 

@After 
public void tearDown() { 
    verifyZeroInteractions(System.out); 
    System.setOut(backup); 
} 

Answer 2

verifyZeroInteractions(systemOut); 

टिप्पणियों में उल्लेख किया गया है, यह एक जासूसी के साथ काम नहीं करता है।

लगभग बराबर लेकिन अधिक पूर्ण उत्तर के लिए, इस प्रश्न के लिए gontard द्वारा उत्तर देखें।

Answer 3

आप एक अलग कील की कोशिश कर सकते:

private PrintStream stdout; 

@Before public void before() { 
    stdout = System.out; 
    OutputStream out = new OutputStream() { 
     @Override public void write(int arg0) throws IOException { 
      throw new RuntimeException("Not allowed"); 
     } 
    }; 
    System.setOut(new PrintStream(out)); 
} 

@After public void after() { 
    System.setOut(stdout); 
} 

यदि आप पसंद करते हैं, तो आप एक नकली के लिए अनाम प्रकार स्विच और as Don Roby suggests सत्यापित कर सकता।

Answer 4

एक तरह से, वर्ग है कि आप परीक्षण कर रहे हैं refactor करने के लिए एक PrintStream कि उत्पादन के लिए इस्तेमाल किया जा सकता का इंजेक्शन के लिए अनुमति देने के लिए है। System कक्षा के व्यवहार पर निर्भर किए बिना, यह आपको यूनिट का परीक्षण करने देगा। आप इस इंजेक्शन के लिए पैकेज-निजी कन्स्ट्रक्टर का उपयोग कर सकते हैं, क्योंकि आप इसे कभी भी इसी टेस्ट क्लास से उपयोग करेंगे। तो यह ऐसा कुछ दिख सकता है।

public class MyClass{ 
    private PrintWriter systemOut; 

    public MyClass(){ 
     this(System.out); 
    } 

    MyClass(PrintWriter systemOut){ 
     this.systemOut = systemOut; 

     // ...any other initialisation processing that you need to do 
    } 
} 

और कक्षा के भीतर, सिस्टम.आउट के बजाय सिस्टमऑट वैरिएबल का उपयोग करें जहां भी आप बाद वाले को कॉल करते हैं।

अब, टेस्ट क्लास के भीतर, एक मॉक PrintStream बनाएं, और उस ऑब्जेक्ट को प्राप्त करने के लिए पैकेज-निजी कन्स्ट्रक्टर को पास करें, जिसे आप परीक्षण करने जा रहे हैं। अब आप अपने परीक्षणों से अपनी पसंद के किसी भी क्रिया को चला सकते हैं, और verify का उपयोग अपने नकली PrintStream पर अपने प्रभावों की जांच के लिए कर सकते हैं।