आउटपुटस्ट्रीम.write (<String>) कोई फ़ाइल बनाने के बिना

Question

परीक्षण करने के बिना मैं जावा में आउटपुट स्ट्रीम का परीक्षण कर रहा हूं।

Writer outputStream = getOutputStream(fileName); 
    if(outputStream != null) { 
     try { 
      outputStream.write(inputText); 
     } 
     finally { 
      outputStream.close(); 
     } 
    } 
    else { 
     throw new IOException("Output stream is null"); 
    } 

मैं

public void testFileWrite() throws IOException { 
    when(testObj.getOutputStream(outputFileNameValidValue)).thenReturn(outputStreamMock); 
    doNothing().when(outputStreamMock).write(Matchers.anyString()); 
    doNothing().when(bufferedReaderMock).close(); 

    testObj.write(outputFileNameValidValue, reveredFileInput); 

    verify(outputStreamMock).write(Matchers.anyString()); 
    verify(outputStreamMock).close(); 
} 

नीचे के रूप में एक mockito परीक्षण लिखने समस्या यह है कि जब आप OutputStreamWriter(new FileOutputStream(filename)) बनाने डिस्क पर एक भौतिक फ़ाइल बनाई गई है हूँ।

क्या हम डिस्क पर फ़ाइल लिखने के बिना Outputstream.write का परीक्षण कर सकते हैं?

धन्यवाद आनंद

Answer 1

आप ByteArrayOutputStream जो स्मृति में डेटा लिखते हैं उपयोग कर सकते हैं। आप इसे एक ByteArrayInputStream के साथ पढ़ सकते हैं।

एक विकल्प आउटपुटस्ट्रीम की अपेक्षा करना एक विकल्प है जो आप गलत बाइट लिखने की कोशिश करते हैं। यह देखने में सहायक हो सकता है कि वास्तव में कहां/क्यों विफल रहता है।

Answer 2

आप कर सकते थे अपने उत्पादन जो वास्तव में एक Printstream है, जो OutputStream का एक उपवर्ग है के लिए System.out का उपयोग करके देखें

देखें: http://docs.oracle.com/javase/6/docs/api/java/lang/System.html http://docs.oracle.com/javase/6/docs /api/java/io/PrintStream.html

Answer 3

आपको अपने getOutputStream का नकल करना चाहिए: मॉक आउटपुट स्ट्रीम ऑब्जेक्ट को वापस करना चाहिए। new FileOutputStream का आमंत्रण वास्तव में डिस्क पर फ़ाइल बनाता है।

सैद्धांतिक रूप से आप फ़ाइल सिस्टम को नकल कर सकते हैं लेकिन यह अधिक जटिल है।

और बीटीडब्ल्यू if(outputStream != null) अनावश्यक है: स्ट्रीम कभी शून्य नहीं हो सकती है। यदि इसे बनाया नहीं जा सकता है तो विधि को अपवाद फेंकना चाहिए। यह सी नहीं है, यह जावा है। :)

Answer 4

आपको मॉक किया गया getOutputStream(String)java.io.StringWriter लौटाएं और फिर आप यह कह सकते हैं कि अपेक्षित सामग्री लिखी गई थी।

public void testFileWrite() throws IOException { 
    StringWriter writer = new StringWriter(); 
    when(testObj.getOutputStream(outputFileNameValidValue)).thenReturn(writer); 

    testObj.write(outputFileNameValidValue, reveredFileInput); 

    assertEquals(reveredFileInput, writer.toString()); 

    verify(writer).close(); 
} 

Answer 5

जैसा कि अन्य सुझाव दिया गया है कि आपको परीक्षण के तहत अपनी कक्षा में एक मॉक आउटपुटस्ट्रीम इंजेक्ट करने में सक्षम होना चाहिए। चूंकि परीक्षण के तहत आपकी कक्षा को आउटपुटस्ट्रीम की आवश्यकता होती है जो किसी दिए गए फ़ाइल में लिखता है, आपको परीक्षण के तहत अपनी कक्षा में एक मॉकटेबल आउटपुटस्ट्रीम फैक्ट्री इंजेक्ट करने की आवश्यकता होगी। - जहां बना सकता हूँ एक `OutputStreamWriter` - मैं इसे अपने कोड में नहीं दिख रहा है

import org.junit.Before; 
import org.junit.Test; 
import org.junit.runner.RunWith; 
import org.mockito.Mock; 
import org.mockito.runners.MockitoJUnitRunner; 

import java.io.IOException; 
import java.io.OutputStream; 

import static org.mockito.Mockito.verify; 
import static org.mockito.Mockito.when; 

@RunWith(MockitoJUnitRunner.class) 
public class Test9328173 { 

    private ClassUnderTest testObj; 

    @Mock 
    private OutputStreamFactory factory; 

    @Mock 
    private OutputStream stream; 

    @Before 
    public void setUp() throws Exception { 
     testObj = new ClassUnderTest(); 
     testObj.factory = factory; 
    } 

    @Test 
    public void testFileWrite() throws Exception { 
     when(factory.create("filename")).thenReturn(stream); 

     testObj.write("filename", new byte[]{1, 2, 3}); 

     verify(stream).write(new byte[]{1, 2, 3}); 
     verify(stream).close(); 
    } 

    private class ClassUnderTest { 

     private OutputStreamFactory factory; 

     public void write(String filename, byte[] content) throws IOException { 
      OutputStream stream = factory.create(filename); 
      try { 
       stream.write(content); 
      } finally { 
       stream.close(); 
      } 
     } 
    } 

    private interface OutputStreamFactory { 

     OutputStream create(String filename); 
    } 
}