මොකිටෝ සමඟ අවලංගු ක්‍රම සමච්චල් කරන්නේ කෙසේද

අවලංගු ආපසු වර්ගයක් සමඟ ක්‍රම සමච්චල් කරන්නේ කෙසේද?

මම නිරීක්ෂක රටාවක් ක්‍රියාත්මක කළ නමුත් මට එය මොකිටෝ සමඟ සමච්චල් කළ නොහැක.

මම අන්තර්ජාලයේ උදාහරණයක් සොයා ගැනීමට උත්සාහ කළ නමුත් එය සාර්ථක වූයේ නැත.

මගේ පන්තිය මේ වගේ ය:

public class World {

    List<Listener> listeners;

    void addListener(Listener item) {
        listeners.add(item);
    }

    void doAction(Action goal,Object obj) {
        setState("i received");
        goal.doAction(obj);
        setState("i finished");
    }

    private string state;
    //setter getter state
} 

public class WorldTest implements Listener {

    @Test public void word{
    World  w= mock(World.class);
    w.addListener(this);
    ...
    ...

    }
}

interface Listener {
    void doAction();
}

පද්ධතිය සමච්චලයට ලක් නොවේ.

ඉහත පද්ධති පද්ධතියේ තත්වය පෙන්වීමට මට අවශ්‍යය. ඔවුන්ට අනුව ප්‍රකාශ කරන්න.

Mockito API ලියකියවිලි දෙස බලන්න . සම්බන්ධිත ලේඛනයක් ලෙස (පේදුරු # 12) සඳහන් ඔබ ඕනෑම භාවිතා කළ හැකිය doThrow(), doAnswer(), doNothing(), doReturn()Mockito රාමුව සිට ක්රම ව්යාජ අඩුව ක්රම පවුල.

උදාහරණයක් වශයෙන්,

Mockito.doThrow(new Exception()).when(instance).methodName();

හෝ පසු විපරම් හැසිරීම සමඟ එය ඒකාබද්ධ කිරීමට ඔබට අවශ්‍ය නම්,

Mockito.doThrow(new Exception()).doNothing().when(instance).methodName();

setState(String s)පහත දැක්වෙන පන්තියේ ලෝකයේ සැකකරුට සරදම් කිරීමට ඔබ බලා සිටින බව උපකල්පනය කිරීම කේතය doAnswerසමච්චල් කිරීමට ක්‍රමය භාවිතා කරයි setState.

World mockWorld = mock(World.class); 
doAnswer(new Answer<Void>() {
    public Void answer(InvocationOnMock invocation) {
      Object[] args = invocation.getArguments();
      System.out.println("called with arguments: " + Arrays.toString(args));
      return null;
    }
}).when(mockWorld).setState(anyString());

මම හිතන්නේ මම එම ප්‍රශ්නයට සරල පිළිතුරක් සොයාගෙන ඇති අතර, එක් ක්‍රමයක් සඳහා සැබෑ ක්‍රමය ඇමතීමට (එය අවලංගු ප්‍රතිලාභයක් තිබුණත්) ඔබට මෙය කළ හැකිය:

Mockito.doCallRealMethod().when(<objectInstance>).<method>();
<objectInstance>.<method>();

නැතහොත්, ඔබට එම පන්තියේ සියලුම ක්‍රම සඳහා සැබෑ ක්‍රමය අමතන්න, මෙය සිදු කිරීම:

<Object> <objectInstance> = mock(<Object>.class, Mockito.CALLS_REAL_METHODS);

Ate සතීෂ් පැවසූ දෙයට එකතු කරමින්, පරීක්ෂණය කැඳවීම වැළැක්වීම සඳහා ඔබට අවලංගු ක්‍රමයක් සමච්චල් කිරීමට අවශ්‍ය වූ විට, ඔබට Spyමේ ආකාරයෙන් භාවිතා කළ හැකිය:

World world = new World();
World spy = Mockito.spy(world);
Mockito.doNothing().when(spy).methodToMock();

ඔබේ පරීක්ෂණය ක්‍රියාත්මක කිරීමට ඔබට අවශ්‍ය වූ විට, ඔබ එම ක්‍රමය පරීක්‍ෂා කිරීමේ ක්‍රමය spyවස්තුව මත නොව වස්තුව මත කැඳවීමට වග බලා ගන්න world. උදාහරණයක් වශයෙන්:

assertEquals(0, spy.methodToTestThatShouldReturnZero());

ඊනියා ප්රශ්නය විසඳීම සඳහා භාවිතා කිරීමයි spy Mockito.spy (...) ඒ වෙනුවට ක mock Mockito.mock (..) .

ඔත්තු බැලීම අපට අර්ධ සමච්චලයට ලක් කරයි. මොකිටෝ මේ කාරණයේදී හොඳයි. ඔබට සම්පූර්ණ නොවන පන්තියක් ඇති හෙයින්, මේ ආකාරයෙන් ඔබ මෙම පන්තියේ අවශ්‍ය ස්ථානයක් සමච්චලයට ලක් කරයි.

පළමුවෙන්ම: ඔබ සැමවිටම මොකිටෝ ස්ථිතික ආනයනය කළ යුතුය, මේ ආකාරයෙන් කේතය වඩාත් කියවිය හැකි (සහ බුද්ධිමත්) වනු ඇත:

import static org.mockito.Mockito.*;

අර්ධ වශයෙන් සමච්චල් කිරීම සහ ඉතිරි ක්‍රියාකාරිත්වය මත තවමත් මුල් ක්‍රියාකාරිත්වය තබා ගැනීම සඳහා "ස්පයි" ඉදිරිපත් කරයි.

ඔබට එය පහත පරිදි භාවිතා කළ හැකිය:

private World world = spy(new World());

ක්රමයක් ක්රියාත්මක කිරීමෙන් ඉවත් කිරීම සඳහා ඔබට මෙවැනි දෙයක් භාවිතා කළ හැකිය:

doNothing().when(someObject).someMethod(anyObject());

ක්‍රමයකට යම් අභිරුචි හැසිරීමක් ලබා දීමට “එවිට” “පසුව නැවත පැමිණීම” සමඟ භාවිතා කරන්න:

doReturn("something").when(this.world).someMethod(anyObject());

තවත් උදාහරණ සඳහා කරුණාකර ලේඛනයේ ඇති විශිෂ්ට මොකිටෝ සාම්පල සොයා ගන්න.

මොකිටෝ සමඟ අවලංගු ක්‍රම සමච්චල් කරන්නේ කෙසේද - විකල්ප දෙකක් තිබේ:

1. doAnswer - අපගේ සමච්චල් කරන ලද අවලංගු ක්‍රමය යමක් කිරීමට අපට අවශ්‍ය නම් (අවලංගු වුවද හැසිරීම සමච්චලයට ලක් කරන්න).
2. doThrow- එවිට Mockito.doThrow()ඔබට සමච්චල් කරන ලද අවලංගු ක්‍රමයෙන් ව්‍යතිරේකයක් විසි කිරීමට අවශ්‍ය නම් තිබේ.

පහත දැක්වෙන්නේ එය භාවිතා කරන ආකාරය පිළිබඳ උදාහරණයකි (පරිපූර්ණ භාවිත කේස් එකක් නොව මූලික භාවිතය නිදර්ශනය කිරීමට අවශ්‍ය විය).

@Test
public void testUpdate() {

    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            Object[] arguments = invocation.getArguments();
            if (arguments != null && arguments.length > 1 && arguments[0] != null && arguments[1] != null) {

                Customer customer = (Customer) arguments[0];
                String email = (String) arguments[1];
                customer.setEmail(email);

            }
            return null;
        }
    }).when(daoMock).updateEmail(any(Customer.class), any(String.class));

    // calling the method under test
    Customer customer = service.changeEmail("old@test.com", "new@test.com");

    //some asserts
    assertThat(customer, is(notNullValue()));
    assertThat(customer.getEmail(), is(equalTo("new@test.com")));

}

@Test(expected = RuntimeException.class)
public void testUpdate_throwsException() {

    doThrow(RuntimeException.class).when(daoMock).updateEmail(any(Customer.class), any(String.class));

    // calling the method under test
    Customer customer = service.changeEmail("old@test.com", "new@test.com");

}
}

ඔබ කළ යුතු ආකාරය ගැන වැඩි විස්තර සොයා ගත හැකි සමච්චල් හා පරීක්ෂා අඩුව මගේ පශ්චාත් Mockito සමග ක්රම Mockito (උදාහරණ සහිත සම්පූර්ණ මගපෙන්වීමක්) සමග සමච්චල් කෙසේද

පොකුරට තවත් පිළිතුරක් එක් කිරීම (කිසිදු ද pun ුවමක් අපේක්ෂා නොකරයි) ...

ඔත්තු බැලීමට භාවිතා කිරීමට ඔබට අවශ්‍ය නැතිනම් ඔබට doAnswer ක්‍රමය අමතන්න. කෙසේ වෙතත්, ඔබට ඔබේම පිළිතුරක් පෙරළීමට අවශ්‍ය නොවේ . පෙරනිමි ක්‍රියාත්මක කිරීම් කිහිපයක් තිබේ. සැලකිය යුතු CallsRealMethods .

ප්රායෝගිකව, එය මේ වගේ දෙයක් පෙනේ:

doAnswer(new CallsRealMethods()).when(mock)
        .voidMethod(any(SomeParamClass.class));

හෝ:

doAnswer(Answers.CALLS_REAL_METHODS.get()).when(mock)
        .voidMethod(any(SomeParamClass.class));

ජාවා 8 හි ඔබට ස්ථිතික ආනයනයක් ඇතැයි උපකල්පනය කරමින් මෙය ටිකක් පිරිසිදු කළ හැකිය org.mockito.Mockito.doAnswer:

doAnswer(i -> {
  // Do stuff with i.getArguments() here
  return null;
}).when(*mock*).*method*(*methodArguments*);

මෙම return null;වැදගත් වන අතර එය තොරව එක්රැස් ඒ සඳහා සුදුසු අභිබවා සොයා ගැනීමට නොහැකි වනු ඇත සමහර තරමක් අප්රකට දෝෂ සහිත අසාර්ථක වනු ඇත doAnswer.

නිදසුනක් ලෙස සම්මත කර ඇති ExecutorServiceඕනෑම දෙයක් වහාම ක්‍රියාත්මක කළ හැකිය.Runnableexecute()

doAnswer(i -> {
  ((Runnable) i.getArguments()[0]).run();
  return null;
}).when(executor).execute(any());

මම හිතන්නේ ඔබේ ගැටළු වලට හේතුව ඔබේ පරීක්ෂණ ව්‍යුහයයි. පරීක්ෂණ පන්තියේ අතුරුමුහුණත් ක්‍රියාත්මක කිරීමේ සාම්ප්‍රදායික ක්‍රමය සමඟ සමච්චල් කිරීම මිශ්‍ර කිරීම මට අපහසු විය (ඔබ මෙහි කළ පරිදි).

ඔබ සවන්දෙන්නෙකු විහිළුවක් ලෙස ක්‍රියාත්මක කරන්නේ නම් ඔබට අන්තර්ක්‍රියා සත්‍යාපනය කළ හැකිය.

Listener listener = mock(Listener.class);
w.addListener(listener);
world.doAction(..);
verify(listener).doAction();

'ලෝකය' නිවැරදි දේ කරන බවට මෙය ඔබව තෘප්තිමත් කළ යුතුය.

Mockito.doThrow භාවිතා කිරීම:

Mockito.doThrow(new Exception()).when(instance).methodName();

ඔබට මෙම කදිම උදාහරණය උත්සාහ කළ හැකිය:

public void testCloseStreamOnException() throws Exception {
    OutputStream outputStream = Mockito.mock(OutputStream.class);
    IFileOutputStream ifos = new IFileOutputStream(outputStream);
    Mockito.doThrow(new IOException("Dummy Exception")).when(outputStream).flush();
    try {
      ifos.close();
      fail("IOException is not thrown");
    } catch (IOException ioe) {
      assertEquals("Dummy Exception", ioe.getMessage());
    }
    Mockito.verify(outputStream).close();
  }

මුලාශ්‍රය: http://apisonar.com/java-examples/org.mockito.Mockito.doThrow.html#Example-19