Java Code Examples for org.mockito.mockito#verifyNoMoreInteractions()

@Test
public void connectFailed_withSocketException() throws Exception {
    Mockito.doThrow(new SocketException()).when(mockSocket).connect(Mockito.any());

    final TcpCollector.ConnectDatum result;
    try (TcpCollector tcpCollector = new TcpCollector(dstAddress, GROUP)) {
        result = tcpCollector.tryConnect(mockSocket);
    }

    assertThat(result.getResult(), equalTo(TcpCollector.ConnectResult.CONNECT_FAILED));
    Mockito.verify(mockSocket, times(1)).connect(Mockito.eq(dstAddress));
    Mockito.verifyNoMoreInteractions(mockSocket);
}
 

@Test
public void testGetCollectionsByAttachTypeAndId() {

    List<Collection> collections = collectionServiceImpl.getCollectionsByAttachTypeAndId(ModuleHelper.userId,
            ModuleHelper.attachId, ModuleHelper.attachType);
    verify(mockedCollectionMapper, times(1)).selectByExample(Mockito.argThat(new ExampleMatcher<CollectionExample>() {

        @Override
        public boolean matches(BaseExample example) {
            return CriterionVerifier.verifyEqualTo(example, "userId", ModuleHelper.userId)
                    && CriterionVerifier.verifyEqualTo(example, "attachType", ModuleHelper.attachType)
                    && CriterionVerifier.verifyEqualTo(example, "attachId", ModuleHelper.attachId);
        }
    }));
    Mockito.verifyNoMoreInteractions(mockedCollectionMapper);
    runAsserts(collections, false);
}
 

@Test
void testLazyObjectHeader() throws ConcurrentException, IOException {
	FileChannel spyFc = Mockito.spy(fc);
	HdfFileChannel hdfFileChannel = new HdfFileChannel(spyFc, sb);
	LazyInitializer<ObjectHeader> lazyObjectHeader = ObjectHeader.lazyReadObjectHeader(hdfFileChannel, 10904); // int8
	// header
	// Creating the lazy object header should not touch the file
	Mockito.verifyNoInteractions(spyFc);

	// Get the actual header should cause the file to be read
	lazyObjectHeader.get();

	// Check the file was read
	verify(spyFc, Mockito.atLeastOnce()).read(any(ByteBuffer.class), anyLong());

	// Ensure nothing else was done to the file
	Mockito.verifyNoMoreInteractions(spyFc);
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void testErrorChannelNotBoundByDefault() {
	ConfigurableApplicationContext applicationContext = SpringApplication.run(
			TestProcessor.class, "--server.port=0",
			"--spring.cloud.stream.default-binder=mock",
			"--spring.jmx.enabled=false");
	BinderFactory binderFactory = applicationContext.getBean(BinderFactory.class);

	Binder binder = binderFactory.getBinder(null, MessageChannel.class);

	Mockito.verify(binder).bindConsumer(eq("input"), isNull(),
			any(MessageChannel.class), any(ConsumerProperties.class));
	Mockito.verify(binder).bindProducer(eq("output"), any(MessageChannel.class),
			any(ProducerProperties.class));
	Mockito.verifyNoMoreInteractions(binder);
	applicationContext.close();
}
 

@Test
@Parameters
public void testApplyToConfigBuilderWithEnumOptions(JacksonOption[] options) {
    new JacksonModule(options)
            .applyToConfigBuilder(this.configBuilder);

    this.verifyCommonConfigurations(true);

    Mockito.verify(this.configBuilder).forMethods();
    Mockito.verify(this.typesInGeneralConfigPart).withSubtypeResolver(Mockito.any());
    Mockito.verify(this.typesInGeneralConfigPart, Mockito.times(2)).withCustomDefinitionProvider(Mockito.any());
    Mockito.verify(this.fieldConfigPart).withTargetTypeOverridesResolver(Mockito.any());
    Mockito.verify(this.fieldConfigPart).withCustomDefinitionProvider(Mockito.any());
    Mockito.verify(this.methodConfigPart).withTargetTypeOverridesResolver(Mockito.any());
    Mockito.verify(this.methodConfigPart).withCustomDefinitionProvider(Mockito.any());

    Mockito.verifyNoMoreInteractions(this.configBuilder, this.fieldConfigPart, this.methodConfigPart, this.typesInGeneralConfigPart);
}
 

@Test
public void testDoubleApply() {
	EvaluatorFactory factory = new EvaluatorFactory();
	factory.appendStatement("param1 := 1.4");
	factory.appendStatement("clip(param1)");
	factory.appendStatement("clip(param2)");

	final ClipStub clipStub = new ClipStub();
	final IJointClip jointClipMock = clipStub.jointClipMock;

	final TRSRTransformation transform1 = TRSRTransformation.from(EnumFacing.NORTH);
	final TRSRTransformation transform2 = TRSRTransformation.from(EnumFacing.WEST);
	Mockito.when(jointClipMock.apply(1.4f)).thenReturn(transform1);
	Mockito.when(jointClipMock.apply(2.1f)).thenReturn(transform2);

	final TRSRTransformation result = factory.createEvaluator(clips("clip", clipStub)).evaluate(DUMMY_JOINT, ImmutableMap.of("param2", 2.1f));
	Assert.assertEquals(transform1.compose(transform2), result);

	Mockito.verify(jointClipMock).apply(1.4f);
	Mockito.verify(jointClipMock).apply(2.1f);
	Mockito.verifyNoMoreInteractions(jointClipMock);
}
 

@Test
public void setTypeFaceForCoachMarkTextNullTypefaceTest() {
    Mockito.when(mTypeFaceProvider.getTypeFaceFromAssets(Matchers.anyString())).thenReturn(null);

    mPopUpCoachMarkPresenter.setTypeFaceForCoachMarkText("fontFilePath");

    Mockito.verify(mTypeFaceProvider, Mockito.times(1)).getTypeFaceFromAssets("fontFilePath");
    Mockito.verify(mPopUpCoachMarkPresentation, Mockito.times(0))
            .setTypeFaceForPopUpText((Typeface) Matchers.anyObject());

    Mockito.verifyNoMoreInteractions(mPopUpCoachMarkPresentation);
}
 

@Test
public void testPanacheRepositoryMocking() throws Throwable {
    Assertions.assertEquals(0, mockablePersonRepository.count());

    Mockito.when(mockablePersonRepository.count()).thenReturn(23l);
    Assertions.assertEquals(23, mockablePersonRepository.count());

    Mockito.when(mockablePersonRepository.count()).thenReturn(42l);
    Assertions.assertEquals(42, mockablePersonRepository.count());

    Mockito.when(mockablePersonRepository.count()).thenCallRealMethod();
    Assertions.assertEquals(0, mockablePersonRepository.count());

    Mockito.verify(mockablePersonRepository, Mockito.times(4)).count();

    PersonEntity p = new PersonEntity();
    Mockito.when(mockablePersonRepository.findById(12l)).thenReturn(p);
    Assertions.assertSame(p, mockablePersonRepository.findById(12l));
    Assertions.assertNull(mockablePersonRepository.findById(42l));

    Mockito.when(mockablePersonRepository.findById(12l)).thenThrow(new WebApplicationException());
    try {
        mockablePersonRepository.findById(12l);
        Assertions.fail();
    } catch (WebApplicationException x) {
    }

    Mockito.when(mockablePersonRepository.findOrdered()).thenReturn(Collections.emptyList());
    Assertions.assertTrue(mockablePersonRepository.findOrdered().isEmpty());

    Mockito.verify(mockablePersonRepository).findOrdered();
    Mockito.verify(mockablePersonRepository, Mockito.atLeastOnce()).findById(Mockito.any());
    Mockito.verifyNoMoreInteractions(mockablePersonRepository);
}
 

@Test public void batchInvokedWithAftereffectThatThrows() {
  MyUncheckedException exception = new MyUncheckedException();
  Funnel.Batch<Integer, String> toSpell = funnel.through(batch::send);
  Consumer<String> throwingEffect = s -> {throw exception;};
  toSpell.accept(1, throwingEffect);
  toSpell.accept(2);
  when(batch.send(asList(1, 2))).thenReturn(asList("one", "two"));
  assertThrows(MyUncheckedException.class, funnel::run);
  Mockito.verify(batch).send(asList(1, 2));
  Mockito.verifyNoMoreInteractions(batch);
}
 

@Test
public void testAbstractVoidHandler_QuoteLiquidityRequest() throws Exception {
  final InterledgerPayment interledgerPayment = mock(InterledgerPayment.class);
  final QuoteLiquidityRequest quoteLiquidityRequest = mock(QuoteLiquidityRequest.class);
  final QuoteLiquidityResponse quoteLiquidityResponse = mock(QuoteLiquidityResponse.class);

  new TestAbstractHandler().execute(quoteLiquidityRequest);

  Mockito.verifyNoMoreInteractions(interledgerPayment);
  Mockito.verify(quoteLiquidityRequest)
      .getDestinationAccount();
  Mockito.verifyNoMoreInteractions(quoteLiquidityResponse);
}
 

@Test
public void testApplyToConfigBuilderWithSkipSubtypeLookupOption() {
    new JacksonModule(JacksonOption.SKIP_SUBTYPE_LOOKUP)
            .applyToConfigBuilder(this.configBuilder);

    this.verifyCommonConfigurations(true);

    Mockito.verify(this.configBuilder).forMethods();
    Mockito.verify(this.typesInGeneralConfigPart).withCustomDefinitionProvider(Mockito.any());
    Mockito.verify(this.fieldConfigPart).withCustomDefinitionProvider(Mockito.any());
    Mockito.verify(this.methodConfigPart).withCustomDefinitionProvider(Mockito.any());

    Mockito.verifyNoMoreInteractions(this.configBuilder, this.fieldConfigPart, this.methodConfigPart, this.typesInGeneralConfigPart);
}
 

@Test
public void testCheckCloudSdkAction_callPluginsCoreChecksSkipJava()
    throws CloudSdkVersionFileException, CloudSdkNotFoundException, CloudSdkOutOfDateException,
        AppEngineJavaComponentsNotInstalledException {
  checkCloudSdkTask.setVersion("192.0.0");
  when(sdk.getVersion()).thenReturn(new CloudSdkVersion("192.0.0"));

  checkCloudSdkTask.checkCloudSdkAction();

  Mockito.verify(sdk).getVersion();
  Mockito.verify(sdk).validateCloudSdk();
  Mockito.verify(sdk, Mockito.never()).validateAppEngineJavaComponents();
  Mockito.verifyNoMoreInteractions(sdk);
}
 

@Test
public void shouldValidateContentTypeOnlyForArrayClass() {
  // given
  JavaType type = TypeFactory.defaultInstance().constructType(Integer[].class);
  setValidatorMockResult(true);

  // when
  variablesResourceSpy.validateType(type);

  // then
  Mockito.verify(validator).validate("java.lang.Integer");
  Mockito.verifyNoMoreInteractions(validator);
}
 

/**
 * @author Steven
 * Test that projectList is empty
 */
@Test
public void testGetCompletedStepsGroupByDateByUser_Test1() {
    TreeMap<Date, Map<Integer, List<Step>>> treeMap = 
            testedStepServiceImpl.getCompletedStepsGroupByDateByUser(
                    ModuleHelper.companyId, ModuleHelper.userId, new ArrayList<Integer>(), ModuleHelper.until, ModuleHelper.limit);
    
    Mockito.verifyNoMoreInteractions(mockStepMapper);
    
    assertEquals(0, treeMap.size());
}
 

@Test
public void testUpdate() throws NoSessionException, NoPeerConnectionException {
	Mockito.stub(h2hFileManager.createUpdateProcess(any())).toReturn(process);
	ProcessHandle<Void> p = fileManager.update(file);
	assertNotNull(p);
	assertNotNull(p.getProcess());
	assertEquals(process, p.getProcess());

	Mockito.verify(h2hFileManager,  times(1)).createUpdateProcess(file.toFile());
	Mockito.verifyNoMoreInteractions(h2hFileManager);
}
 

@Test
public void testToDeployConfiguration_allValuesSet() {
  DeployExtension testExtension = new DeployExtension(testProject);
  testExtension.setDeployTargetResolver(deployTargetResolver);

  testExtension.setBucket("test-bucket");
  testExtension.setGcloudMode("beta");
  testExtension.setImageUrl("test-img-url");
  testExtension.setProjectId("test-project-id");
  testExtension.setPromote(true);
  testExtension.setServer("test-server");
  testExtension.setStopPreviousVersion(true);
  testExtension.setVersion("test-version");

  List<Path> projects = ImmutableList.of(Paths.get("project1"), Paths.get("project2"));
  DeployConfiguration config = testExtension.toDeployConfiguration(projects);

  Assert.assertEquals(projects, config.getDeployables());
  Assert.assertEquals("test-bucket", config.getBucket());
  Assert.assertEquals("beta", config.getGcloudMode());
  Assert.assertEquals("test-img-url", config.getImageUrl());
  Assert.assertEquals("processed-project-id", config.getProjectId());
  Assert.assertEquals(Boolean.TRUE, config.getPromote());
  Assert.assertEquals("test-server", config.getServer());
  Assert.assertEquals(Boolean.TRUE, config.getStopPreviousVersion());
  Assert.assertEquals("processed-version", config.getVersion());

  Mockito.verify(deployTargetResolver).getProject("test-project-id");
  Mockito.verify(deployTargetResolver).getVersion("test-version");
  Mockito.verifyNoMoreInteractions(deployTargetResolver);
}
 

@Test
public void testApplyToConfigBuilderWithDefaultOptions() {
    new JavaxValidationModule().applyToConfigBuilder(this.configBuilder);

    this.verifyCommonConfigurations();

    Mockito.verifyNoMoreInteractions(this.configBuilder, this.fieldConfigPart, this.methodConfigPart);
}
 

@Test
public void testProto3MapIntMessageSpecsCompliant() throws Exception {
  RecordConsumer readConsumerMock =  Mockito.mock(RecordConsumer.class);
  Configuration conf = new Configuration();
  ProtoWriteSupport.setWriteSpecsCompliant(conf, true);
  ProtoWriteSupport instance = createReadConsumerInstance(TestProto3.MapIntMessage.class, readConsumerMock, conf);

  TestProto3.MapIntMessage.Builder msg = TestProto3.MapIntMessage.newBuilder();
  msg.putMapInt(123, 1);
  msg.putMapInt(234, 2);
  instance.write(msg.build());

  InOrder inOrder = Mockito.inOrder(readConsumerMock);

  inOrder.verify(readConsumerMock).startMessage();
  inOrder.verify(readConsumerMock).startField("mapInt", 0);
  inOrder.verify(readConsumerMock).startGroup();
  inOrder.verify(readConsumerMock).startField("key_value", 0);

  inOrder.verify(readConsumerMock).startGroup();
  inOrder.verify(readConsumerMock).startField("key", 0);
  inOrder.verify(readConsumerMock).addInteger(123);
  inOrder.verify(readConsumerMock).endField("key", 0);
  inOrder.verify(readConsumerMock).startField("value", 1);
  inOrder.verify(readConsumerMock).addInteger(1);
  inOrder.verify(readConsumerMock).endField("value", 1);
  inOrder.verify(readConsumerMock).endGroup();

  inOrder.verify(readConsumerMock).startGroup();
  inOrder.verify(readConsumerMock).startField("key", 0);
  inOrder.verify(readConsumerMock).addInteger(234);
  inOrder.verify(readConsumerMock).endField("key", 0);
  inOrder.verify(readConsumerMock).startField("value", 1);
  inOrder.verify(readConsumerMock).addInteger(2);
  inOrder.verify(readConsumerMock).endField("value", 1);
  inOrder.verify(readConsumerMock).endGroup();

  inOrder.verify(readConsumerMock).endField("key_value", 0);
  inOrder.verify(readConsumerMock).endGroup();
  inOrder.verify(readConsumerMock).endField("mapInt", 0);
  inOrder.verify(readConsumerMock).endMessage();
  Mockito.verifyNoMoreInteractions(readConsumerMock);
}
 

@Test
public void testRestoreInstances_rightHandler_vmRunning() throws Exception {

	// Prepare stuff
	INotificationMngr notificationMngr = Mockito.mock( INotificationMngr.class );
	IRandomMngr randomMngr = Mockito.mock( IRandomMngr.class );
	ITargetConfigurator targetConfigurator = Mockito.mock( ITargetConfigurator.class );

	IMessagingMngr messagingMngr = Mockito.mock( IMessagingMngr.class );
	Mockito.when( messagingMngr.getMessagingClient()).thenReturn( Mockito.mock( IDmClient.class ));

	ITargetsMngr targetsMngr = Mockito.mock( ITargetsMngr.class );
	Mockito.when( targetsMngr.findTargetProperties(
			Mockito.any( Application.class ),
			Mockito.anyString())).thenReturn( new TargetPropertiesImpl());

	IConfigurationMngr configurationMngr = new ConfigurationMngrImpl();
	configurationMngr.setWorkingDirectory( this.folder.newFolder());

	final TargetHandler targetHandlerArgument = Mockito.mock( TargetHandler.class );
	Mockito.when( targetHandlerArgument.getTargetId()).thenReturn( "some target id" );

	IInstancesMngr mngr = new InstancesMngrImpl( messagingMngr, notificationMngr, targetsMngr, randomMngr, targetConfigurator );
	((InstancesMngrImpl) mngr).setTargetHandlerResolver( new TestTargetResolver() {
		@Override
		public TargetHandler findTargetHandler( Map<String,String> targetProperties ) throws TargetException {
			return targetHandlerArgument;
		}
	});

	TestApplication app = new TestApplication();
	app.setDirectory( this.folder.newFolder());
	ManagedApplication ma = new ManagedApplication( app );

	// One scoped instance has a machine ID (considered as running somewhere)
	app.getMySqlVm().data.put( Instance.MACHINE_ID, "machine-id" );
	app.getMySqlVm().setStatus( InstanceStatus.DEPLOYING );

	// Try to restore instances
	Assert.assertEquals( InstanceStatus.DEPLOYING, app.getMySqlVm().getStatus());
	Mockito.when( targetHandlerArgument.isMachineRunning(
			Mockito.any( TargetHandlerParameters.class ),
			Mockito.eq( "machine-id" ))).thenReturn( true );

	mngr.restoreInstanceStates( ma, targetHandlerArgument );
	Assert.assertEquals( InstanceStatus.DEPLOYING, app.getMySqlVm().getStatus());

	// The handler's ID matched and the VM is running => a message was sent.
	Mockito.verify( targetsMngr ).findTargetProperties( Mockito.eq( app ), Mockito.anyString());
	Mockito.verify( targetsMngr ).findScriptForDm( Mockito.eq( app ), Mockito.eq( app.getMySqlVm()));
	Mockito.verify( targetsMngr ).unlockTarget( Mockito.eq( app ), Mockito.eq( app.getTomcatVm()));
	Mockito.verifyNoMoreInteractions( targetsMngr );

	Mockito.verify( targetHandlerArgument, Mockito.times( 1 )).isMachineRunning(
			Mockito.any( TargetHandlerParameters.class ),
			Mockito.eq( "machine-id" ));

	Mockito.verify( messagingMngr ).getMessagingClient();
	Mockito.verify( messagingMngr ).sendMessageDirectly(
			Mockito.eq( ma ),
			Mockito.eq( app.getMySqlVm() ),
			Mockito.any( MsgCmdSendInstances.class ));
	Mockito.verifyNoMoreInteractions( messagingMngr );

	// No notification was sent since there was no change on Tomcat instances
	Mockito.verifyZeroInteractions( notificationMngr );
	Mockito.verifyZeroInteractions( randomMngr );
	Mockito.verifyZeroInteractions( targetConfigurator );
}
 

@Test
public void testExecuteAsync() throws InvalidProcessStateException, ProcessExecutionException {
	handle.executeAsync();
	Mockito.verify(process, Mockito.times(1)).executeAsync();
	Mockito.verifyNoMoreInteractions(process);
}