問題描述

我正在嘗試使用任何"匹配器來存根此 getKeyFromStream 方法.我嘗試過更加明確和不明確(anyObject())，但似乎無論我嘗試什么，這個存根都不會在我的單元測試中返回 fooKey.

I'm trying to stub this getKeyFromStream method, using the 'any' matchers. I've tried being more explicit and less explicit (anyObject()), but it seems like no matter what I try, this stub will not return the fooKey in my unit test.

我想知道是因為它受到保護還是我遺漏了其他東西或做錯了什么.我在整個測試中還有其他 when/then 語句正在運行，但由于某種原因，這里不是.

I'm wondering if it is because it is protected or there is something else I'm missing or doing incorrectly. I have other when/then statements throughout the tests that are working but for some reason here, it is not.

注意:getKeyFromStream 一般使用 byteArrayInputStream，但我正在嘗試將其與 InputStream 匹配，我都嘗試過均無濟于事.

Note: The getKeyFromStream generally uses a byteArrayInputStream, but I'm trying to match it with an InputStream, I've tried both to no avail.

public class FooKeyRetriever() //Mocked this guy
{
    public FooKey getKey(String keyName) throws KeyException {

        return getKeyFromStream(getKeyStream(keyName, false), keyName);
    }

    //Stubbed this method to return a key object which has been mocked
    protected FooKey getKeyFromStream(InputStream keyStream, String keyName){
        //Some code
        return fooKey;
    }
}

單元測試

@Mock
private FooKeyRetriever mockKeyRetriever;

@Mock
private FooKey fooKey;

@Before
public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
}

@Test
public void testGetFooKey() throws Exception {



    when(foo.getKeyFromStream(any(InputStream.class),any(String.class))).thenReturn(fooKey);

    FooKey fooKey = mockKeyRetriever.getKey("irrelevant_key");

    assertNotNull(fooKey);
}

推薦答案

你的單元測試的問題是，你試圖模擬你想要測試的實際類的方法，但你實際上不能調用一個模擬方法，因為這將返回 null ，除非您在該調用的方法上聲明一個模擬返回值.通常，您只模擬外部依賴項.

The problem with your unit-test is, that you are trying to mock a method of your actual class which you want to test but you can't actually invoke a mock method as this will return null unless you declare a mocked return value on that invoked method. Usually, you only mock external dependencies.

實際上有兩種方法可以創建測試對象:mock 和 spy.入門者將根據您提供的類創建一個新對象，該對象具有內部狀態 null 并且在每個調用的方法上都返回 null.這就是為什么您需要為方法調用定義某些返回值.spy 另一方面，如果為某些方法定義了模擬定義"，則會創建一個真實對象并攔截方法調用.

There are actually two ways to create test-objects: mock and spy. The primer one will create a new object based on the class you provided which has internal state null and also return null on every invoked method. That's why you need to define certain return values for method invocations. spy on the other hand creates a real object and intercepts method invocations if "mock definitions" are defined for certain methods.

Mockito 和 PowerMock 提供了兩種定義模擬方法的方法:

Mockito and PowerMock provide two ways of defining your mocked methods:

// method 1
when(mockedObject.methodToMock(any(Param1.class), any(Param2.class),...)
    .thenReturn(answer);
when(mockedObject, method(Dependency.class, "methodToMock", Parameter1.class, Parameter2.class, ...)
    .thenReturn(answer);

或

// method 2
doReturn(answer).when(mockedObject).methodToMock(param1, param2);

不同之處在于，方法 1 將執行方法實現，而后一個不會.如果您處理 spy 對象，這一點很重要，因為您有時不想在調用的方法中執行真正的代碼，而只是替換代碼或返回預定義的值！

The difference is, that the method 1 will execute the methods implementation while the later one won't. This is important if you deal with spy objects as you sometimes don't want to execute the real code inside the invoked method but instead just replace the code or return a predefined value!

盡管 Mockito 和 PowerMock 提供了一個 doCallRealMethod()，您可以定義它來代替 doReturn(...) 或 doThrow(...)，這將在您的真實對象中調用并執行代碼，并忽略任何模擬方法返回語句.但是，在您想要模擬被測類的方法的情況下，這并不是很有用.

Although Mockito and PowerMock provide a doCallRealMethod() which you can define instead of doReturn(...) or doThrow(...), this will invoke and execute the code within your real object and ignores any mocked method return statements. Though, this is not that useful in your case where you want to mock a method of your class under test.

方法實現可以被

doAnswer(Answer<T>() { 
    @Override 
    public T answer(InvocationOnMock invocation) throws Throwable {
        ...
    }
)

您可以簡單地聲明被調用方法的邏輯應該是什么.您可以利用它來返回受保護方法的模擬結果，因此如下所示:

where you simply can declare what the logic of the invoked method should be. You can utilize this to return the mock result of the protected method therefore like this:

import static org.hamcrest.core.IsSame.sameInstance;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;

import java.io.InputStream;

import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

public class FooKeyRetrieverTest {

    @Test
    public void testGetFooKey() throws Exception {
        // Arrange
        final FooKeyRetriever sut = spy(new FooKeyRetriever());
        FooKey mockedKey = mock(FooKey.class);

        doReturn(mockedKey)
            .when(sut).getKeyFromStream(any(InputStream.class), anyString());
        doAnswer(new Answer<FooKey>() {

            public FooKey answer(InvocationOnMock invocation) throws Throwable {
                return sut.getKeyFromStream(null, "");
            }
        }).when(sut).getKey(anyString());

        // Act
        FooKey ret = sut.getKey("test");

        // Assert
        assertThat(ret, sameInstance(mockedKey));
    }
}

上面的代碼可以工作，但是請注意，這與簡單地將 getKey(...) 的返回值聲明為

The code above works, however note that this has the same semantic as simply declaring a return value for the getKey(...) as

doReturn(mockedKey).when(sut).getKey(anyString());

嘗試僅使用以下內容修改 getKeyFromStream(...):

Trying to modify only getKeyFromStream(...) with something like this:

doReturn(mockedKey)
    .when(sut).getKeyFromStream(any(InputStream.class), anyString());

不修改您的被測系統 (SUT) 的 getKey(...) 將無法實現任何實際代碼 getKey(...) 將被執行.但是，如果您模擬 sut 對象，則無法調用 //Act 部分中的方法，因為這將返回 null.如果你嘗試

without modifying getKey(...) of your System-Under-Test (SUT) won't achieve anything as the real code of getKey(...) would be executed. If you however mock the sut-object, you could not invoke the method in your // Act section as this would return null. If you try

doCallRealMethod().when(sut).getKey(anyString());

在模擬對象上，將調用真正的方法，如前所述，這也將調用 getKeyFromStream(...) 和 getKeyStream(...) 的真正實現 不管你指定什么模擬方法.

on a mock object, the real method woulb be called and as mentiond beforehand, this would also invoke the real implementations of getKeyFromStream(...) and getKeyStream(...) regardless what you specified as mock-method.

正如您自己可能看到的那樣，實際測試類的模擬方法并沒有那么有用，而且給您帶來的負擔比它提供的任何好處都多.因此，如果您想要或需要測試私有/受保護的方法，或者您堅持只測試公共 API(我會推薦)，這取決于您或您的企業的政策.您還可以重構您的代碼 以提高可測試性，盡管主要目的是重構應該是提高整體代碼設計.

As you probably can see by yourself, mocking methods of your actual class under test is not that useful and puts more burden to you than it provides any good. Therefore, it's up to you or your enterprise' policy if you want or need to test private/protected methods at all or if you stick to testing only the public API (which I would recommend). You also have the possibility to refactor your code in order to improve testability although the primary intent of refactoring should be to improve the overall design of your code.

這篇關于Mockito 何時/然后不返回預期值的文章就介紹到這了，希望我們推薦的答案對大家有所幫助，也希望大家多多支持html5模板網！