Comment se moquer de variables locales à l'aide mockito ou powermock

J'ai scénario comme celui-ci 

InputStreamReader reader = new InputStreamReader(getFileAsStream(resourceResolver, iconpath));
                BufferedReader bReader = new BufferedReader(reader);

J'ai moqué jusqu'à ce point 

getFileAsStream(resourceResolver, iconpath)

maintenant, je suis un lecteur 

 BufferedReader bReader = new BufferedReader(reader);

mais quand j'exécute cette ligne-je obtenir nul et n'est pas en mesure d'aller de l'avant 

  while ((iconEntry = bReader.readLine()) != null)

S'il vous plaît dites-moi comment puis-je me moquer de ce.
Veuillez noter que je ne peux changer mon code principal c'est pourquoi la solution présents sur Mockito docs n'est pas valable dans mon cas

Code de Test

@RunWith(PowerMockRunner.class)
@PrepareForTest({ FrameworkUtil.class, LoggerFactory.class })
public class IconPreviewServletTest {
private IconPreviewServlet iconPreviewServlet;
private SlingHttpServletRequest request;
private SlingHttpServletResponse response;
private Bundle bundle;
private BundleContext bundleContext;
private ServiceReference factoryRef;
private CommonService resolverFactory;
private PrintWriter out;
private ResourceResolver resourceResolver;
private Resource resource;
private Node node;
private Node jcrContent;
private javax.jcr.Property property;
private Binary binary;
private InputStream stream;
private InputStreamReader inputReader;
private BufferedReader reader;
@Before
public void setUp() throws IOException, PathNotFoundException,
RepositoryException {
init();
}
private void init() throws IOException, PathNotFoundException,
RepositoryException {
request = mock(SlingHttpServletRequest.class);
response = mock(SlingHttpServletResponse.class);
bundleContext = mock(BundleContext.class);
factoryRef = mock(ServiceReference.class);
resolverFactory = mock(CommonService.class);
out = mock(PrintWriter.class);
resourceResolver = mock(ResourceResolver.class);
resource = mock(Resource.class);
node = mock(Node.class);
jcrContent = mock(Node.class);
property = mock(Property.class);
binary = mock(Binary.class);
stream=IOUtils.toInputStream("some test data for my input stream");
reader = mock(BufferedReader.class);
inputReader=mock(InputStreamReader.class);
bundle = mock(Bundle.class);
mockStatic(FrameworkUtil.class);
mockStatic(LoggerFactory.class);
Logger log = mock(Logger.class);
when(LoggerFactory.getLogger(IconPreviewServlet.class)).thenReturn(log);
when(FrameworkUtil.getBundle(CommonService.class)).thenReturn(bundle);
when(bundle.getBundleContext()).thenReturn(bundleContext);
when(bundleContext.getServiceReference(CommonService.class.getName()))
.thenReturn(factoryRef);
when(bundleContext.getService(factoryRef)).thenReturn(resolverFactory);
when(request.getParameter("category")).thenReturn("category");
when(request.getParameter("query")).thenReturn("query");
when(response.getWriter()).thenReturn(out);
when(request.getResourceResolver()).thenReturn(resourceResolver);
when(
resourceResolver
.getResource("/etc/designs/resmed/icons/category/icons.txt"))
.thenReturn(resource);
when(resource.adaptTo(Node.class)).thenReturn(node);
when(node.getNode("jcr:content")).thenReturn(jcrContent);
when(jcrContent.getProperty("jcr:data")).thenReturn(property);
when(property.getBinary()).thenReturn(binary);
when(binary.getStream()).thenReturn(stream);
}
pourriez-vous montrer le code de test ?
test de code ajouté

OriginalL'auteur ankit | 2013-11-16

  1. 10

    Pour faire ce travail, vous devez utiliser Powermockito pour intercepter le constructeur appelle (new InputStreamReader(...), new BufferedReader (...)), de sorte que votre se moque de renvoi. Un exemple ci-dessous. Dans votre cas, il suffit d'intercepter le new BufferedReader appel peut être suffisant.

    Supposons que celui-ci est le code que vous voulez tester:

    package test;
import java.io.*;
public class SUT {
public String doSomething() throws IOException {
InputStreamReader reader =
new InputStreamReader(getFileAsStream(null, null));
BufferedReader bReader =
new BufferedReader(reader);
return bReader.readLine();
}
private InputStream getFileAsStream(Object resourceResolver, Object iconPath)
throws FileNotFoundException {
return new ByteArrayInputStream("".getBytes());
}
}

    Le test code suivant est un exemple de comment intercepter le constructeur appelle:

    package test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import static org.junit.Assert.assertEquals;
import static org.powermock.api.mockito.PowerMockito.doReturn;
import static org.powermock.api.mockito.PowerMockito.mock;
@RunWith(PowerMockRunner.class)
@PrepareForTest({ SUT.class })
public class SUTTest {
@Test
public void doSomethingReturnsValueFromBufferedReader() throws Exception {
//Arrange
SUT sut = new SUT();
InputStreamReader inputStreamReaderMock = mock(InputStreamReader.class);
BufferedReader bufferedReaderMock = mock(BufferedReader.class);
//Set your mocks up to be returned when the new ...Reader calls 
//are executed in sut.doSomething()
PowerMockito.whenNew(InputStreamReader.class).
withAnyArguments().thenReturn(inputStreamReaderMock);
PowerMockito.whenNew(BufferedReader.class).
withArguments(inputStreamReaderMock).
thenReturn(bufferedReaderMock);
//Set the value you want bReader.readLine() to return 
//when sut.doSomething() executes
final String bufferedReaderReturnValue = "myValue";
doReturn(bufferedReaderReturnValue).when(bufferedReaderMock).readLine();
//Act
String result = sut.doSomething();
//Assert
assertEquals(bufferedReaderReturnValue, result);
}
}

    Cela devrait vous aide dans votre problème immédiat. Cependant, il me semble que ce que vous êtes en train de créer sera un très lente, déroutant et test fragile. Maintenant, vous êtes moqueur tellement que cela rend très difficile de déterminer ce que vous êtes réellement en train de tester.

    Le montant élevé de se moquer indique probablement que la conception du code, vous effectuez le test aurait besoin de quelques travaux pour améliorer la testabilité. Si vous ne pouvez pas toucher au code, alors vous ne pouvez pas - mais essayer de faire votre test plus lisible et intuitive ("Lorsque cette méthode est appelée, cette chose doit arriver, parce que...").

    OriginalL'auteur Lauri Harpf

  2. 1

    pour faire fonctionner cette ligne:

     while ((iconEntry = bReader.readLine()) != null)

    vous devez déterminer le nombre de lignes que vous voulez lire et l'ajouter à votre code de test:

    when(bReader.readLine()).thenReturn("line number one").thenReturn("line number two");
    dans mon cas, bReader est un objet original alors, comment puis-je appeler quand sur elle. Si j'essaie de le faire, j'obtiens une exception. En disant que vous appelez lorsque sur un non se moquaient de l'objet
    vous avez à se moquer de bReader également, mais vous avez déjà mis à votre code de test: "lecteur = se moquer(BufferedReader.class);" donc, juste l'utiliser pour appeler des readLine() la fonction

    OriginalL'auteur Tien Nguyen