public String printInvocations(Object mock) { Collection<Invocation> invocations = Mockito.mockingDetails(mock).getInvocations(); Collection<Stubbing> stubbings = Mockito.mockingDetails(mock).getStubbings(); if (invocations.isEmpty() && stubbings.isEmpty()) { return "No interactions and stubbings found for mock: " + mock;
@Override public IndexRepository computeIndexRepository(final Integer bucketId, LuceneSerializer serializer, InternalLuceneIndex index, PartitionedRegion userRegion, IndexRepository oldRepository, PartitionedRepositoryManager partitionedRepositoryManager) throws IOException { final IndexRepository indexRepo = super.computeIndexRepository(bucketId, serializer, index, userRegion, oldRepository, partitionedRepositoryManager); if (indexRepo == null) { return null; } if (mockingDetails(indexRepo).isSpy()) { return indexRepo; } final IndexRepository spy = Mockito.spy(indexRepo); Answer invokeBeforeWrite = invocation -> { beforeWrite.accept(invocation.getArgument(0)); return invocation.callRealMethod(); }; doAnswer(invokeBeforeWrite).when(spy).update(any(), any()); doAnswer(invokeBeforeWrite).when(spy).create(any(), any()); doAnswer(invokeBeforeWrite).when(spy).delete(any()); return spy; }
public void setMock(Object mock) { if (mock == null) { throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock", "null parameter."); } MockingDetails mockingDetails = Mockito.mockingDetails(mock); if (!mockingDetails.isMock()) { throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock", "parameter which is not a Mockito mock.\n" + " Received parameter: " + ValuePrinter.print(mock) + ".\n "); } MockCreationSettings originalMockSettings = this.originalMockingDetails.getMockCreationSettings(); assertCompatibleTypes(mock, originalMockSettings); this.mock = mock; }
private DatabaseLookup spyLookup( StepMockHelper<DatabaseLookupMeta, DatabaseLookupData> mocks, Database db, DatabaseMeta dbMeta ) { DatabaseLookup lookup = new DatabaseLookup( mocks.stepMeta, mocks.stepDataInterface, 1, mocks.transMeta, mocks.trans ); lookup = Mockito.spy( lookup ); doReturn( db ).when( lookup ).getDatabase( eq( dbMeta ) ); for ( RowSet rowSet : lookup.getOutputRowSets() ) { if ( mockingDetails( rowSet ).isMock() ) { when( rowSet.putRow( any( RowMetaInterface.class ), any( Object[].class ) ) ).thenReturn( true ); } } return lookup; }
TopicFilter topicFilter = spoutConfig.getTopicFilter(); ManualPartitioner topicPartitioner = spoutConfig.getTopicPartitioner(); if (!mockingDetails(topicFilter).isMock() || !mockingDetails(topicPartitioner).isMock()) { throw new IllegalStateException("Use a mocked TopicFilter and a mocked ManualPartitioner when using this method, it helps avoid complex stubbing");
private static void verify(Object mock, Method expectedMethod, Object... expectedArguments) { out: for (Invocation invocation : Mockito.mockingDetails(mock).getInvocations()) { if (invocation.getMethod().equals(expectedMethod)) { Object[] actualArguments = invocation.getArguments(); assert actualArguments.length == expectedArguments.length; // because it's the same method for (int i = 0; i < actualArguments.length; i++) { Object actual = actualArguments[i]; Object expected = expectedArguments[i]; boolean equal = (actual == null) ? expected == null : actual.equals(expected); if (!equal) { continue out; } } invocation.markVerified(); return; } } throw new WantedButNotInvoked("Not delegated: " + expectedMethod.toString()); } }
/** * Delegates call to {@link Mockito#mockingDetails(Object)}. */ default MockingDetails mockingDetails(Object toInspect) { return Mockito.mockingDetails(toInspect); }
/** * Delegates call to {@link Mockito#mockingDetails(Object)}. */ default MockingDetails mockingDetails(Object toInspect) { return Mockito.mockingDetails(toInspect); }
MockHandlerAdaptor(final T mock) { this.mock = mock; this.invocationFactory = new InvocationFactory(); this.mockingDetails = Mockito.mockingDetails(mock); }
private boolean isFastTest() { return Mockito.mockingDetails(accountApi).isMock(); } }
private boolean isFastTest() { return Mockito.mockingDetails(accountInternalApi).isMock(); } }
@Test public void testJudgeMock() { A a = mock(A.class); A b = spy(new A()); Assert.assertTrue(Mockito.mockingDetails(a).isMock()); Assert.assertFalse(Mockito.mockingDetails(a).isSpy()); Assert.assertTrue(Mockito.mockingDetails(b).isMock()); Assert.assertTrue(Mockito.mockingDetails(b).isSpy()); }
/** * If the underlying instance is mocked, any {@link TunnelToServer} annotation is removed. */ @Override protected void interceptRegisterBean(BeanMetaData beanData) { super.interceptRegisterBean(beanData); if (Mockito.mockingDetails(beanData.getInitialInstance()).isMock() && beanData.getBeanAnnotation(TunnelToServer.class) != null) { LOG.info("removing TunnelToServer annotation on mocked bean: {}", beanData.getBeanClazz()); beanData.withoutAnnotation(TunnelToServer.class); } } }
public ResourceGroupEntity mockResourceGroupEntity(String name, Set<ResourceEntity> resources) { ResourceGroupEntity mock = mock(ResourceGroupEntity.class); Integer id = getNextId(); when(mock.getId()).thenReturn(id); when(mock.getName()).thenReturn(name); when(mock.getResources()).thenReturn(resources); if (resources != null) { for (ResourceEntity r : resources) { if (Mockito.mockingDetails(r).isMock()) { when(r.getResourceGroup()).thenReturn(mock); } } } return mock; }
private void setConsumedMasterRelations(ConsumedResourceRelationEntity mock, ResourceEntity master) { Set<ConsumedResourceRelationEntity> masterRelations = master.getConsumedMasterRelations() != null ? master.getConsumedMasterRelations() : new HashSet<ConsumedResourceRelationEntity>(); masterRelations.add(mock); if (Mockito.mockingDetails(master).isMock()) { when(master.getConsumedMasterRelations()).thenReturn(masterRelations); } else { master.setConsumedMasterRelations(masterRelations); } }
private void setProvidedSlaveRelations(ProvidedResourceRelationEntity mock, ResourceEntity slave) { Set<ProvidedResourceRelationEntity> slaveRelations = slave.getProvidedSlaveRelations() != null ? slave.getProvidedSlaveRelations() : new HashSet<ProvidedResourceRelationEntity>(); slaveRelations.add(mock); if (Mockito.mockingDetails(slave).isMock()) { when(slave.getProvidedSlaveRelations()).thenReturn(slaveRelations); } else { slave.setProvidedMasterRelations(slaveRelations); } } }
private void setConsumedSlaveRelations(ConsumedResourceRelationEntity mock, ResourceEntity slave) { Set<ConsumedResourceRelationEntity> slaveRelations = slave.getConsumedSlaveRelations() != null ? slave.getConsumedSlaveRelations() : new HashSet<ConsumedResourceRelationEntity>(); slaveRelations.add(mock); if (Mockito.mockingDetails(slave).isMock()) { when(slave.getConsumedSlaveRelations()).thenReturn(slaveRelations); } else { slave.setConsumedMasterRelations(slaveRelations); } }
private void setProvidedMasterRelations(ProvidedResourceRelationEntity mock, ResourceEntity master) { Set<ProvidedResourceRelationEntity> masterRelations = master.getProvidedMasterRelations() != null ? master.getProvidedMasterRelations() : new HashSet<ProvidedResourceRelationEntity>(); masterRelations.add(mock); if (Mockito.mockingDetails(master).isMock()) { when(master.getProvidedMasterRelations()).thenReturn(masterRelations); } else { master.setProvidedMasterRelations(masterRelations); } }
@Test public void testParallelismAndMetrics() { this.containerStorageManager.start(); this.containerStorageManager.shutdown(); for (Gauge gauge : taskRestoreMetricGauges.values()) { Assert.assertTrue("Restoration time gauge value should be invoked atleast once", Mockito.mockingDetails(gauge).getInvocations().size() >= 1); } Assert.assertTrue("Store restore count should be 2 because there are 2 tasks", this.storeRestoreCallCount == 2); Assert.assertTrue("systemConsumerCreation count should be 1 (1 consumer per system)", this.systemConsumerCreationCount == 1); Assert.assertTrue("systemConsumerStopCount count should be 1", this.systemConsumerStopCount == 1); Assert.assertTrue("systemConsumerStartCount count should be 1", this.systemConsumerStartCount == 1); } }
@Test public void setFieldValueWithMockShouldCreateAMockAndSetTheMockInTheCorrectFieldAndReturnTheMock() { final CustomTestClass customTestClass = new CustomTestClass(); assertNull(customTestClass.getTestClass()); final TestClass testClassMock = TestUtils.setFieldValueWithMock(customTestClass, "testClass", TestClass.class); assertSame(testClassMock, customTestClass.getTestClass()); final MockingDetails mockingDetails = mockingDetails(testClassMock); assertTrue(mockingDetails.isMock()); }