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 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 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 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; }
/** * 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()); }