Java 类org.mockito.MockSettings 实例源码

private EventCollector(Class<Target> targetClass, EventCombiner<Target, Event> combiner,
        Collection<Predicate<? super Event>> filters) {

    this.combiner = Objects.requireNonNull(combiner, "Event combiner cannot be null!");
    this.eventFilters = ImmutableList.copyOf(filters);
    this.eventHandlers = selectEventHandlers(filters);

    List<DescribedInvocation> invocations = new ArrayList<>();
    MockSettings settings = Mockito.withSettings()
        .invocationListeners(report -> invocations.add(report.getInvocation()));

    this.target = Mockito.mock(targetClass, settings);
    combiner.accept(Mockito.doAnswer(this::answer).when(target));

    if (invocations.size() != 1)
        throw new IllegalStateException("Single listener interaction was expected! But actual: " + invocations);

    this.invocation = invocations.get(0);
}

public Object process(Mock annotation, Field field) {
    MockSettings mockSettings = Mockito.withSettings();
    if (annotation.extraInterfaces().length > 0) { // never null
        mockSettings.extraInterfaces(annotation.extraInterfaces());
    }
    if ("".equals(annotation.name())) {
        mockSettings.name(field.getName());
    } else {
        mockSettings.name(annotation.name());
    }
    if(annotation.serializable()){
        mockSettings.serializable();
    }

    // see @Mock answer default value
    mockSettings.defaultAnswer(annotation.answer().get());
    return Mockito.mock(field.getType(), mockSettings);
}

@Override
public Object getParameterValue(Parameter parameter) {
  Mock annotation = parameter.getAnnotation(Mock.class);
  MockSettings settings = Mockito.withSettings();
  if (annotation.extraInterfaces().length > 0) {
    settings.extraInterfaces(annotation.extraInterfaces());
  }
  if (annotation.serializable()) {
    settings.serializable();
  }
  settings.name(annotation.name().isEmpty() ? parameter.getName() : annotation.name());
  settings.defaultAnswer(annotation.answer());

  return Mockito.mock(parameter.getType(), settings);
}

@Override
public MockSettings apply(MockSettings mockSettings) {
    if(Answer.class.equals(answerClass)) {
        return mockSettings;
    }

    return mockSettings.defaultAnswer(createAnswerInstance());
}

@Override
public MockSettings apply(MockSettings mockSettings) {
    if(listenerClasses.isEmpty()) {
        return mockSettings;
    }

    return mockSettings.invocationListeners(createListeners());
}

public MockSettings createMockSettings(MockSettings mockSettings) {
    MockSettings settings = mockSettings;
    for (SettingsDecorator decorator : settingsDecorators) {
        settings = decorator.apply(settings);
    }
    return settings;
}

@SuppressWarnings("unchecked")
public <T> T createSpy(String name, Object instance) {
    Assert.notNull(instance, "Instance must not be null");
    Assert.isInstanceOf(this.classToSpy, instance);
    if (this.mockUtil.isSpy(instance)) {
        return (T) instance;
    }
    MockSettings settings = MockReset.withSettings(getReset());
    if (StringUtils.hasLength(name)) {
        settings.name(name);
    }
    settings.spiedInstance(instance);
    settings.defaultAnswer(Mockito.CALLS_REAL_METHODS);
    return (T) Mockito.mock(instance.getClass(), settings);
}

@SuppressWarnings("unchecked")
public <T> T createMock(String name) {
    MockSettings settings = MockReset.withSettings(getReset());
    if (StringUtils.hasLength(name)) {
        settings.name(name);
    }
    if (!this.extraInterfaces.isEmpty()) {
        settings.extraInterfaces(this.extraInterfaces.toArray(new Class<?>[] {}));
    }
    settings.defaultAnswer(getAnswer(this.answer));
    if (this.serializable) {
        settings.serializable();
    }
    return (T) Mockito.mock(this.classToMock, settings);
}

@SuppressWarnings("unchecked")
public <T> T createSpy(String name, Object instance) {
    Assert.notNull(instance, "Instance must not be null");
    Assert.isInstanceOf(this.classToSpy, instance);
    if (this.mockUtil.isSpy(instance)) {
        return (T) instance;
    }
    MockSettings settings = MockReset.withSettings(getReset());
    if (StringUtils.hasLength(name)) {
        settings.name(name);
    }
    settings.spiedInstance(instance);
    settings.defaultAnswer(Mockito.CALLS_REAL_METHODS);
    return (T) Mockito.mock(instance.getClass(), settings);
}

@SuppressWarnings("unchecked")
public <T> T createMock(String name) {
    MockSettings settings = MockReset.withSettings(getReset());
    if (StringUtils.hasLength(name)) {
        settings.name(name);
    }
    if (!this.extraInterfaces.isEmpty()) {
        settings.extraInterfaces(this.extraInterfaces.toArray(new Class<?>[] {}));
    }
    settings.defaultAnswer(this.answer.get());
    if (this.serializable) {
        settings.serializable();
    }
    return (T) Mockito.mock(this.classToMock, settings);
}

public static <T> T mock(final Class<T> classToMock, final MockSettings mockSettings) {
    return AccessController.doPrivileged(new PrivilegedAction<T>() {
        @Override
        public T run() {
            return org.mockito.Mockito.mock(classToMock, mockSettings);
        }
    });
}

public static MockSettings withSettings() {
    return AccessController.doPrivileged(new PrivilegedAction<MockSettings>() {
        @Override
        public MockSettings run() {
            return org.mockito.Mockito.withSettings();
        }
    });
}

public MockSettings invocationListeners(InvocationListener... listeners) {
       if (listeners == null || listeners.length == 0) {
           new Reporter().invocationListenersRequiresAtLeastOneListener();
       }
       for (InvocationListener listener : listeners) {
           if (listener == null) {
               new Reporter().invocationListenerDoesNotAcceptNullParameters();
           }
           this.invocationListeners.add(listener);
       }
    return this;
}

@Test
public void testAddBreakpoint() throws Exception {
  MockSettings mockSettings =
      new MockSettingsImpl<>().defaultAnswer(RETURNS_SMART_NULLS).extraInterfaces(Resource.class);
  Project project = mock(Project.class);
  when(optional.isPresent()).thenReturn(true);
  when(optional.get()).thenReturn(project);
  when(project.getPath()).thenReturn(PATH);

  VirtualFile virtualFile = mock(VirtualFile.class, mockSettings);
  Path path = mock(Path.class);
  when(path.toString()).thenReturn(PATH);
  when(virtualFile.getLocation()).thenReturn(path);
  when(virtualFile.toString()).thenReturn(PATH);

  Resource resource = (Resource) virtualFile;
  when(resource.getRelatedProject()).thenReturn(optional);
  doReturn(promiseVoid).when(service).addBreakpoint(SESSION_ID, breakpointDto);
  doReturn(promiseVoid).when(promiseVoid).then((Operation<Void>) any());
  doReturn(breakpointDto).when(debugger).toDto(any(Breakpoint.class));

  debugger.addBreakpoint(breakpointDto);

  verify(service).addBreakpoint(SESSION_ID, breakpointDto);
  verify(promiseVoid).then(operationVoidCaptor.capture());
  operationVoidCaptor.getValue().apply(null);
  verify(observer).onBreakpointAdded(breakpointCaptor.capture());
  assertEquals(breakpointCaptor.getValue(), breakpointDto);

  verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
  operationPromiseErrorCaptor.getValue().apply(promiseError);
  verify(promiseError).getMessage();
}

private void setUpMockCreator(){
    ClassLoader loader = targetClass.getClassLoader();
    try {
        Class<?> mockito = loader.loadClass(Mockito.class.getName());
        mockCreator = mockito.getDeclaredMethod("mock",
                loader.loadClass(Class.class.getName()), loader.loadClass(MockSettings.class.getName()));

    } catch (Exception e) {
        logger.error("Failed to setup mock creator: "+e.getMessage());
    }
}

private Object processAnnotationOn(Mock annotation, Field field) {
    MockSettings mockSettings = Mockito.withSettings();
    if (annotation.extraInterfaces().length > 0) { // never null
        mockSettings.extraInterfaces(annotation.extraInterfaces());
    }
    if ("".equals(annotation.name())) {
        mockSettings.name(field.getName());
    } else {
        mockSettings.name(annotation.name());
    }

    // see @Mock answer default value
    mockSettings.defaultAnswer(annotation.answer().get());
    return Mockito.mock(field.getType(), mockSettings);
}

private MockSettings withSettingsUsing(GenericMetadataSupport returnTypeGenericMetadata) {
    MockSettings mockSettings = returnTypeGenericMetadata.hasRawExtraInterfaces() ?
            withSettings().extraInterfaces(returnTypeGenericMetadata.rawExtraInterfaces())
            : withSettings();

    return mockSettings
      .serializable()
            .defaultAnswer(returnsDeepStubsAnswerUsing(returnTypeGenericMetadata));
}

public MockSettings invocationListeners(InvocationListener... listeners) {
    if (listeners == null || listeners.length == 0) {
        new Reporter().invocationListenersRequiresAtLeastOneListener();
    }
    for (InvocationListener listener : listeners) {
        if (listener == null) {
            new Reporter().invocationListenerDoesNotAcceptNullParameters();
        }
        this.invocationListeners.add(listener);
    }
    return this;
}

public static MockSettings async(MockSettings settings) {
    return settings.invocationListeners(new InvocationListener() {

        @Override
        public void reportInvocation(MethodInvocationReport methodInvocationReport) {
            DescribedInvocation invocation = methodInvocationReport.getInvocation();
            if (invocation instanceof InvocationOnMock) {
                Object mock = ((InvocationOnMock) invocation).getMock();
                synchronized (mock) {
                    mock.notifyAll();
                }
            }
        }
    });
}

MockitoDoubleFactory(Supplier<MockSettings> defaultSettingsProvider) {
    this.defaultSettingsProvider = defaultSettingsProvider;
}

@Override
public MockSettings apply(MockSettings mockSettings) {
    return mockSettings.extraInterfaces(extraInterfaces.toArray(new Class[extraInterfaces.size()]));
}

@Override
public MockSettings apply(MockSettings mockSettings) {
    return mockSettings.name(name);
}

@Override
public MockSettings apply(MockSettings mockSettings) {
    return mockSettings.serializable(serializableMode);
}

@Override
public MockSettings apply(MockSettings mockSettings) {
    return stubOnly
            ? mockSettings.stubOnly()
            : mockSettings;
}

@Override
public MockSettings apply(MockSettings mockSettings) {
    return verbose
            ? mockSettings.verboseLogging()
            : mockSettings;
}

public static MockSettings mockSettingsMock() {
    return Mockito.spy(Mockito.withSettings());
}

public MockSettings serializable() {
    this.serializable = true;
    return this;
}

public MockSettings verboseLogging() {
       if (!invocationListenersContainsType(VerboseMockInvocationLogger.class)) {
           invocationListeners(new VerboseMockInvocationLogger());
       }
       return this;
}

/**
 * Delegates call to {@link Mockito#mock(Class, MockSettings)}.
 */
default <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
    return Mockito.mock(classToMock, mockSettings);
}

/**
 * Delegates call to {@link Mockito#withSettings()}.
 */
default MockSettings withSettings() {
    return Mockito.withSettings();
}

protected MockSettings createMockSettings() {
    return withSettings().invocationListeners(listener);
}

protected MockSettings createMockSettings() {
    return withSettings().defaultAnswer(CALLS_REAL_METHODS).invocationListeners(listener);
}

public void mockingStarted(Object mock, Class classToMock, MockSettings mockSettings) {
    if (listener != null && listener instanceof MockingStartedListener) {
        ((MockingStartedListener) listener).mockingStarted(mock, classToMock, mockSettings);
    }
    validateMostStuff();
}

public void mockingStarted(Object mock, Class classToMock, MockSettings mockSettings) {
    threadSafely().mockingStarted(mock, classToMock, mockSettings);
}

public MockSettings serializable() {
    this.serializable = true;
    return this;
}

public void mockingStarted(Object mock, Class classToMock, MockSettings mockSettings) {
    toBeFilled.add(mock);
}

public MockSettings serializable() {
    return serializable(SerializableMode.BASIC);
}

public MockSettings serializable(SerializableMode mode) {
    this.serializableMode = mode;
    return this;
}

public MockSettings verboseLogging() {
    if (!invocationListenersContainsType(VerboseMockInvocationLogger.class)) {
        invocationListeners(new VerboseMockInvocationLogger());
    }
    return this;
}

/**
 * This will prevent spring from creating proxy for any annotations which causes to wrap bean in proxy (@Async for example)
 *
 * @see AbstractAdvisingBeanPostProcessor#postProcessAfterInitialization(java.lang.Object, java.lang.String)
 * <p>
 * I will probably need to revise this in the future because spock doesn't allow to create mocks from multiple interfaces :(
 * https://github.com/spockframework/spock/issues/576
 */
private MockSettings prepareMockSettings(DoubleDefinition doubleDefinition) {
    return doubleDefinition
            .getConfiguration(MockitoDoubleConfiguration.class)
            .createMockSettings(defaultSettingsProvider.get());
}