Java 类org.mockito.mock.MockCreationSettings 实例源码

@Test
public void createMock() throws Exception {
    MockDefinition definition = new MockDefinition("name", ExampleService.class,
            new Class<?>[] { ExampleExtraInterface.class },
            Answers.RETURNS_SMART_NULLS, true, MockReset.BEFORE, true);
    ExampleService mock = definition.createMock();
    MockCreationSettings<?> settings = new MockUtil().getMockSettings(mock);
    assertThat(mock).isInstanceOf(ExampleService.class);
    assertThat(mock).isInstanceOf(ExampleExtraInterface.class);
    assertThat(settings.getMockName().toString()).isEqualTo("name");
    assertThat(settings.getDefaultAnswer())
            .isEqualTo(Answers.RETURNS_SMART_NULLS.get());
    assertThat(settings.isSerializable()).isTrue();
    assertThat(MockReset.get(mock)).isEqualTo(MockReset.BEFORE);
}

@Test
public void createSpy() throws Exception {
    SpyDefinition definition = new SpyDefinition("name", RealExampleService.class,
            MockReset.BEFORE, true);
    RealExampleService spy = definition.createSpy(new RealExampleService("hello"));
    MockCreationSettings<?> settings = new MockUtil().getMockSettings(spy);
    assertThat(spy).isInstanceOf(ExampleService.class);
    assertThat(settings.getMockName().toString()).isEqualTo("name");
    assertThat(settings.getDefaultAnswer())
            .isEqualTo(Answers.CALLS_REAL_METHODS.get());
    assertThat(MockReset.get(spy)).isEqualTo(MockReset.BEFORE);
}

public InternalMockHandler create(MockCreationSettings settings) {
    InternalMockHandler handler = new MockHandlerImpl(settings);
    InternalMockHandler nullResultGuardian = new NullResultGuardian(handler);
    InternalMockHandler notifier = new InvocationNotifierHandler(nullResultGuardian, settings);

    return notifier;
}

/**
 * Creates the wrapper that be used in the serialization stream.
 *
 * <p>Immediately serializes the Mockito mock using specifically crafted {@link MockitoMockObjectOutputStream},
 * in a byte array.</p>
 *
 * @param mockitoMock The Mockito mock to serialize.
 * @throws IOException
 */
public AcrossJVMMockSerializationProxy(Object mockitoMock) throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ObjectOutputStream objectOutputStream = new MockitoMockObjectOutputStream(out);

    objectOutputStream.writeObject(mockitoMock);

    objectOutputStream.close();
    out.close();

    MockCreationSettings mockSettings = new MockUtil().getMockSettings(mockitoMock);
    this.serializedMock = out.toByteArray();
    this.typeToMock = mockSettings.getTypeToMock();
    this.extraInterfaces = mockSettings.getExtraInterfaces();
}

public <T> T createMock(MockCreationSettings<T> settings) {
    MockHandler mockHandler = new MockHandlerFactory().create(settings);

    T mock = mockMaker.createMock(settings, mockHandler);

    Object spiedInstance = settings.getSpiedInstance();
    if (spiedInstance != null) {
        new LenientCopyTool().copyToMock(spiedInstance, mock);
    }

    return mock;
}

public <T> void resetMock(T mock) {
    InternalMockHandler oldHandler = (InternalMockHandler) getMockHandler(mock);
    MockCreationSettings settings = oldHandler.getMockSettings();
    MockHandler newHandler = new MockHandlerFactory().create(settings);

    mockMaker.resetMock(mock, newHandler, settings);
}

@Test
//see issue 331
public void handle_result_must_not_be_null_for_primitives() throws Throwable {
    //given:
    MockCreationSettings settings = (MockCreationSettings) new MockSettingsImpl().defaultAnswer(new Returns(null));
    InternalMockHandler handler = new MockHandlerFactory().create(settings);

    mock.intReturningMethod();
    Invocation invocation = super.getLastInvocation();

    //when:
    Object result = handler.handle(invocation);

    //then null value is not a valid result for a primitive
    assertNotNull(result);
    assertEquals(0, result);
}

@Test
//see issue 331
public void valid_handle_result_is_permitted() throws Throwable {
    //given:
    MockCreationSettings settings = (MockCreationSettings) new MockSettingsImpl().defaultAnswer(new Returns(123));
    InternalMockHandler handler = new MockHandlerFactory().create(settings);

    mock.intReturningMethod();
    Invocation invocation = super.getLastInvocation();

    //when:
    Object result = handler.handle(invocation);

    //then
    assertEquals(123, result);
}

@Override
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
    InvocationHandlerAdapter adapter = getInvocationHandlerAdapter(mock);
    if (adapter != null) {
        adapter.setHandler(newHandler);
    }
}

@Test
public void createMock() throws Exception {
    MockDefinition definition = new MockDefinition("name", ExampleService.class,
            new Class<?>[] { ExampleExtraInterface.class },
            Answers.RETURNS_SMART_NULLS, true, MockReset.BEFORE, true);
    ExampleService mock = definition.createMock();
    MockCreationSettings<?> settings = new MockUtil().getMockSettings(mock);
    assertThat(mock).isInstanceOf(ExampleService.class);
    assertThat(mock).isInstanceOf(ExampleExtraInterface.class);
    assertThat(settings.getMockName().toString()).isEqualTo("name");
    assertThat(settings.getDefaultAnswer())
            .isEqualTo(Answers.RETURNS_SMART_NULLS.get());
    assertThat(settings.isSerializable()).isTrue();
    assertThat(MockReset.get(mock)).isEqualTo(MockReset.BEFORE);
}

@Test
public void createSpy() throws Exception {
    SpyDefinition definition = new SpyDefinition("name", RealExampleService.class,
            MockReset.BEFORE, true);
    RealExampleService spy = definition.createSpy(new RealExampleService("hello"));
    MockCreationSettings<?> settings = new MockUtil().getMockSettings(spy);
    assertThat(spy).isInstanceOf(ExampleService.class);
    assertThat(settings.getMockName().toString()).isEqualTo("name");
    assertThat(settings.getDefaultAnswer())
            .isEqualTo(Answers.CALLS_REAL_METHODS.get());
    assertThat(MockReset.get(spy)).isEqualTo(MockReset.BEFORE);
}

@SuppressWarnings("rawtypes") // The MockCreationListener interface forces this
@Override
public void onMockCreated(Object mock, MockCreationSettings settings) {
    mocks.add(mock);
}

public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
    return cglibMockMaker.createMock(settings, handler);
}

public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
    cglibMockMaker.resetMock(mock, newHandler, settings);
}

public MockCreationSettings getMockSettings() {
    final MockSettingsImpl mockSettings = new MockSettingsImpl();
    mockSettings.setMockName(new MockNameImpl(mock.getName()));
    mockSettings.setTypeToMock(mock);
    return mockSettings;
}

public PowerMockMethodInterceptorFilter(InternalMockHandler handler,
        MockCreationSettings mockSettings) {
    super(handler, mockSettings);
}

public MethodInterceptorFilter(InternalMockHandler handler, MockCreationSettings mockSettings) {
    this.handler = handler;
    this.mockSettings = mockSettings;
}

public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
    InternalMockHandler mockitoHandler = cast(handler);
    new AcrossJVMSerializationFeature().enableSerializationAcrossJVM(settings);
    return new ClassImposterizer(new InstantiatorProvider().getInstantiator(settings)).imposterise(
            new MethodInterceptorFilter(mockitoHandler, settings), settings.getTypeToMock(), settings.getExtraInterfaces());
}

public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
    ((Factory) mock).setCallback(0, new MethodInterceptorFilter(cast(newHandler), settings));
}

/**
 * Creates the wrapper that be used in the serialization stream.
 *
 * <p>Immediately serializes the Mockito mock using specifically crafted
 * {@link AcrossJVMSerializationFeature.MockitoMockObjectOutputStream},
 * in a byte array.</p>
 *
 * @param mockitoMock The Mockito mock to serialize.
 * @throws IOException
 */
public AcrossJVMMockSerializationProxy(Object mockitoMock) throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ObjectOutputStream objectOutputStream = new MockitoMockObjectOutputStream(out);

    objectOutputStream.writeObject(mockitoMock);

    objectOutputStream.close();
    out.close();

    MockCreationSettings mockSettings = new MockUtil().getMockSettings(mockitoMock);
    this.serializedMock = out.toByteArray();
    this.typeToMock = mockSettings.getTypeToMock();
    this.extraInterfaces = mockSettings.getExtraInterfaces();
}

public MockCreationSettings<T> confirm(Class<T> typeToMock) {
    return validatedSettings(typeToMock, this);
}

@Override
@SuppressWarnings("rawtypes")
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
  InvocationHandlerAdapter adapter = getInvocationHandlerAdapter(mock);
  adapter.setHandler(newHandler);
}

public InvocationContainerImpl(MockingProgress mockingProgress, MockCreationSettings mockSettings) {
    this.mockingProgress = mockingProgress;
    this.registeredInvocations = createRegisteredInvocations(mockSettings);
}

private RegisteredInvocations createRegisteredInvocations(MockCreationSettings mockSettings) {
    return mockSettings.isStubOnly()
      ? new SingleRegisteredInvocation()
      : new DefaultRegisteredInvocations();
}

public InvocationNotifierHandler(InternalMockHandler<T> mockHandler, MockCreationSettings settings) {
    this.mockHandler = mockHandler;
    this.invocationListeners = settings.getInvocationListeners();
}

public MockCreationSettings getMockSettings() {
    return mockHandler.getMockSettings();
}

public MockCreationSettings getMockSettings() {
    return delegate.getMockSettings();
}

public MockHandlerImpl(MockCreationSettings mockSettings) {
    this.mockSettings = mockSettings;
    this.mockingProgress = new ThreadSafeMockingProgress();
    this.matchersBinder = new MatchersBinder();
    this.invocationContainerImpl = new InvocationContainerImpl(mockingProgress, mockSettings);
}

public MockCreationSettings getMockSettings() {
    return mockSettings;
}

public MethodInterceptorFilter(InternalMockHandler handler, MockCreationSettings mockSettings) {
    this.handler = handler;
    this.mockSettings = mockSettings;
}

public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
    InternalMockHandler mockitoHandler = cast(handler);
    new AcrossJVMSerializationFeature().enableSerializationAcrossJVM(settings);
    return ClassImposterizer.INSTANCE.imposterise(
            new MethodInterceptorFilter(mockitoHandler, settings), settings.getTypeToMock(), settings.getExtraInterfaces());
}

public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
    ((Factory) mock).setCallback(0, new MethodInterceptorFilter(cast(newHandler), settings));
}

public MockCreationSettings<T> confirm(Class<T> typeToMock) {
    return validatedSettings(typeToMock, this);
}

public MockCreationSettings getMockSettings(Object mock) {
    return getMockHandler(mock).getMockSettings();
}

@Override
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
    InvocationHandlerAdapter adapter = getInvocationHandlerAdapter(mock);
    adapter.setHandler(newHandler);
}

/**
 * Enable serialization serialization that will work across classloaders / and JVM.
 * <p/>
 * <p>Only enable if settings says the mock should be serializable. In this case add the
 * {@link AcrossJVMMockitoMockSerializable} to the extra interface list.</p>
 *
 * @param settings Mock creation settings.
 * @param <T>      Type param to not be bothered by the generics
 */
public <T> void enableSerializationAcrossJVM(MockCreationSettings<T> settings) {
    if (settings.getSerializableMode() == SerializableMode.ACROSS_CLASSLOADERS) {
        // havin faith that this set is modifiable
        // TODO use a proper way to add the interface
        settings.getExtraInterfaces().add(AcrossJVMMockitoMockSerializable.class);
    }
}

/**
 * Enable serialization serialization that will work across classloaders / and JVM.
 *
 * <p>Only enable if settings says the mock should be serializable. In this case add the
 * {@link AcrossJVMMockitoMockSerializable} to the extra interface list.</p>
 *
 * @param settings Mock creation settings.
 * @param <T> Type param to not be bothered by the generics
 */
public <T> void enableSerializationAcrossJVM(MockCreationSettings<T> settings) {
    if (settings.getSerializableMode() == SerializableMode.ACROSS_CLASSLOADERS) {
        // havin faith that this set is modifiable
        // TODO use a proper way to add the interface
        settings.getExtraInterfaces().add(AcrossJVMMockitoMockSerializable.class);
    }
}

/**
 * If you want to provide your own implementation of {@code MockMaker} this method should:
 * <ul>
 *     <li>Create a proxy object that implements {@code settings.typeToMock} and potentially also {@code settings.extraInterfaces}.</li>
 *     <li>You may use the information from {@code settings} to create/configure your proxy object.</li>
 *     <li>Your proxy object should carry the {@code handler} with it. For example, if you generate byte code
 *     to create the proxy you could generate an extra field to keep the {@code handler} with the generated object.
 *     Your implementation of {@code MockMaker} is required to provide this instance of {@code handler} when
 *     {@link #getHandler(Object)} is called.
 *     </li>
 * </ul>
 *
 * @param settings - mock creation settings like type to mock, extra interfaces and so on.
 * @param handler See {@link org.mockito.invocation.MockHandler}.
 *                <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
 *                {@link #getHandler(Object)} will return this instance.
 * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
 * @return The mock instance.
 * @since 1.9.5
 */
<T> T createMock(
        MockCreationSettings<T> settings,
        MockHandler handler
);

/**
 * Replaces the existing handler on {@code mock} with {@code newHandler}.
 *
 * <p>The invocation handler actually store invocations to achieve
 * stubbing and verification. In order to reset the mock, we pass
 * a new instance of the invocation handler.</p>
 *
 * <p>Your implementation should make sure the {@code newHandler} is correctly associated to passed {@code mock}</p>
 *
 * @param mock The mock instance whose invocation handler is to be replaced.
 * @param newHandler The new invocation handler instance.
 * @param settings The mock settings - should you need to access some of the mock creation details.
 * @since 1.9.5
 */
void resetMock(
        Object mock,
        MockHandler newHandler,
        MockCreationSettings settings
);

MockCreationSettings getMockSettings();