Java Examples for org.powermock.api.mockito.PowerMockito.verifyNew

@Test
public void testParameterPassing() throws Exception {
    // when
    whenNew(CService.class).withArguments(anyString(), anyInt(), anyString(), anyString(), anyString(), anyBoolean()).thenReturn(mock(CService.class));
    factory.create("smslib://COM1", "COM1", new ParameterMap("baud", "9600", "manufacturer", "Nokia", "model", "1200", "handler", "Nokia_S40_3ed"));
    // then
    verifyNew(CService.class).withArguments("COM1", 9600, "Nokia", "1200", "Nokia_S40_3ed", true);
}

@Test
public // TODO This should actually work in the future when issue 148 is resolved.
void verifyingNewWithoutExpectationWhenNoArgumentsThrowsISE() throws Exception {
    ExpectNewDemo tested = new ExpectNewDemo();
    assertEquals("Hello world", tested.getMessage());
    try {
        verifyNew(MyClass.class).withNoArguments();
        fail("IllegalStateException expected");
    } catch (IllegalStateException e) {
        assertEquals("No instantiation of class samples.newmocking.MyClass was recorded " + "during the test. Note that only expected object creations " + "(e.g. those using whenNew(..)) can be verified.", e.getMessage());
    }
}

@Test
public void shouldCreateChromeAndStartService() throws Exception {
    ChromeDriver mockChromeDriver = mock(ChromeDriver.class);
    whenNew(ChromeDriver.class).withParameterTypes(ChromeDriverService.class, Capabilities.class).withArguments(isA(ChromeDriverService.class), isA(Capabilities.class)).thenReturn(mockChromeDriver);
    ChromeDriverService.Builder mockServiceBuilder = mock(ChromeDriverService.Builder.class);
    whenNew(ChromeDriverService.Builder.class).withNoArguments().thenReturn(mockServiceBuilder);
    when(mockServiceBuilder.usingDriverExecutable(isA(File.class))).thenReturn(mockServiceBuilder);
    ChromeDriverService mockService = mock(ChromeDriverService.class);
    when(mockServiceBuilder.build()).thenReturn(mockService);
    final ChromeDriver browser = config.createBrowser();
    assertThat(browser, is(mockChromeDriver));
    verifyNew(ChromeDriver.class, times(1)).withArguments(isA(ChromeDriverService.class), isA(Capabilities.class));
    verify(mockServiceBuilder, times(1)).build();
    assertThat(config.getServices().size(), is(1));
    assertThat(config.getServices().values(), hasItem(mockService));
}

@Test
public /**
     * for {@link ReportingService#reportExecutionRequest(String)}
     */
void should_return_proper_builder_instance() throws Exception {
    // Given
    ReportExecutionRequestBuilder builderMock = mock(ReportExecutionRequestBuilder.class);
    whenNew(ReportExecutionRequestBuilder.class).withArguments(sessionStorageMock, "id").thenReturn(builderMock);
    ReportingService serviceSpy = PowerMockito.spy(new ReportingService(sessionStorageMock));
    // When
    ReportExecutionRequestBuilder retrieved = serviceSpy.reportExecutionRequest("id");
    // Then
    assertNotNull(retrieved);
    assertSame(retrieved, builderMock);
    verifyNew(ReportExecutionRequestBuilder.class).withArguments(sessionStorageMock, "id");
}

@Before
public void setUp() throws Exception {
    whenNew(EPPolicyTemplateProviderRegistryImpl.class).withNoArguments().thenReturn(templateProviderRegistry);
    whenNew(SxpMapperReactorImpl.class).withArguments(endpointService, dataBroker).thenReturn(sxpMapperReactor);
    whenNew(SimpleCachedDaoImpl.class).withNoArguments().thenReturn(epPolicyTemplateCachedDao, masterDBBindingCachedDao);
    whenNew(SimpleCachedDaoEPForwardingTemplateImpl.class).withNoArguments().thenReturn(epFwTemplateCachedDao);
    stub(method(EPTemplateUtil.class, "createEndpointGroupIdOrdering")).toReturn(groupOrdering);
    stub(method(EPTemplateUtil.class, "createConditionNameOrdering")).toReturn(conditionOrdering);
    whenNew(EpPolicyTemplateValueKeyFactory.class).withArguments(groupOrdering, conditionOrdering).thenReturn(epPolicyTemplateKeyFactory);
    whenNew(EPPolicyTemplateDaoImpl.class).withArguments(dataBroker, epPolicyTemplateCachedDao, epPolicyTemplateKeyFactory).thenReturn(epPolicyTemplateDao);
    whenNew(SgtGeneratorImpl.class).withArguments(sgtGeneratorConfig).thenReturn(sgtGenerator);
    whenNew(EPPolicyTemplateDaoFacadeImpl.class).withArguments(dataBroker, epPolicyTemplateDao, epPolicyTemplateCachedDao, sgtGenerator).thenReturn(epPolicyTemplateDaoFacade);
    whenNew(EPToSgtMapperImpl.class).withArguments(epPolicyTemplateDaoFacade).thenReturn(epToSgtMapper);
    whenNew(EPForwardingTemplateDaoImpl.class).withArguments(dataBroker, epFwTemplateCachedDao).thenReturn(epForwardingTemplateDao);
    whenNew(MasterDatabaseBindingDaoImpl.class).withArguments(dataBroker, masterDBBindingCachedDao).thenReturn(masterDBBindingDao);
    whenNew(MasterDatabaseBindingListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, masterDBBindingCachedDao, epPolicyTemplateDaoFacade, epForwardingTemplateDao).thenReturn(masterDBBindingListener);
    whenNew(EPPolicyTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epPolicyTemplateCachedDao, masterDBBindingDao, epForwardingTemplateDao).thenReturn(epPolicyTemplateListener);
    whenNew(EPForwardingTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epFwTemplateCachedDao, masterDBBindingDao, epPolicyTemplateDaoFacade).thenReturn(epForwardingTemplateListener);
    whenNew(SxpEndpointAugmentorImpl.class).withArguments(epPolicyTemplateDao, epPolicyTemplateKeyFactory).thenReturn(sxpEPAugmentor);
    provider = new SxpEpProviderProviderImpl(dataBroker, endpointService, domainSpecificRegistry, sgtGeneratorConfig);
    Mockito.verify(templateProviderRegistry).addDistributionTarget(epPolicyTemplateDaoFacade);
    // check if all expected object got constructed and wired
    verifyNew(EPPolicyTemplateProviderRegistryImpl.class).withNoArguments();
    verifyNew(SxpMapperReactorImpl.class).withArguments(endpointService, dataBroker);
    verifyNew(SimpleCachedDaoImpl.class, Mockito.times(2)).withNoArguments();
    verifyNew(SimpleCachedDaoEPForwardingTemplateImpl.class).withNoArguments();
    verifyNew(EpPolicyTemplateValueKeyFactory.class).withArguments(groupOrdering, conditionOrdering);
    verifyNew(EPPolicyTemplateDaoImpl.class).withArguments(dataBroker, epPolicyTemplateCachedDao, epPolicyTemplateKeyFactory);
    verifyNew(SgtGeneratorImpl.class).withArguments(sgtGeneratorConfig);
    verifyNew(EPPolicyTemplateDaoFacadeImpl.class).withArguments(dataBroker, epPolicyTemplateDao, epPolicyTemplateCachedDao, sgtGenerator);
    verifyNew(EPToSgtMapperImpl.class).withArguments(epPolicyTemplateDaoFacade);
    verifyNew(EPForwardingTemplateDaoImpl.class).withArguments(dataBroker, epFwTemplateCachedDao);
    verifyNew(MasterDatabaseBindingDaoImpl.class).withArguments(dataBroker, masterDBBindingCachedDao);
    verifyNew(MasterDatabaseBindingListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, masterDBBindingCachedDao, epPolicyTemplateDaoFacade, epForwardingTemplateDao);
    verifyNew(EPPolicyTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epPolicyTemplateCachedDao, masterDBBindingDao, epForwardingTemplateDao);
    verifyNew(EPForwardingTemplateListenerImpl.class).withArguments(dataBroker, sxpMapperReactor, epFwTemplateCachedDao, masterDBBindingDao, epPolicyTemplateDaoFacade);
}

@Test
public void shouldGetRegimenTemplateForProgram() throws Exception {
    ArrayList<RegimenColumn> regimenColumns = new ArrayList<RegimenColumn>() {

        {
            add(new RegimenColumn());
        }
    };
    RegimenTemplate regimenTemplate = new RegimenTemplate(1L, regimenColumns);
    when(repository.getRegimenColumnsByProgramId(1L)).thenReturn(regimenColumns);
    whenNew(RegimenTemplate.class).withArguments(1L, regimenColumns).thenReturn(regimenTemplate);
    RegimenTemplate template = service.getRegimenTemplateOrMasterTemplate(1L);
    verifyNew(RegimenTemplate.class).withArguments(1L, regimenColumns);
    assertThat(template, is(regimenTemplate));
    verify(repository).getRegimenColumnsByProgramId(1L);
}

@Test
public void testInitWithEndpoint() throws Exception {
    PowerMockito.mock(ViSearchHttpClientImpl.class);
    PowerMockito.whenNew(ViSearchHttpClientImpl.class).withAnyArguments().thenReturn(Mockito.mock(ViSearchHttpClientImpl.class));
    ViSearch viSearch = new ViSearch("localhost", "accessKey", "secretKey");
    verifyNew(ViSearchHttpClientImpl.class).withArguments(eq("localhost"), eq("accessKey"), eq("secretKey"));
}

@Test
public void testMojoConfigurationConfigSrc() throws Exception {
    suppress(method(ResponderGenMojo.class, "execute", File.class, File.class, File.class));
    ResponderGenMojo rgm = new ResponderGenMojo();
    rgm.setEdmxFile("blah.edmx");
    rgm.setSrcTargetDirectory("./tmp");
    File fileMock = mock(File.class);
    whenNew(File.class).withArguments(String.class).thenReturn(fileMock);
    rgm.execute();
    verifyNew(File.class, times(1)).withArguments("blah.edmx");
    // verify that config directory is set to src directory
    verifyNew(File.class, times(2)).withArguments("./tmp");
}

@Test
public void testMigrateShouldNotMigrate() throws Exception {
    whenNew(MigrateUnverifiedDataToVerified.class).withAnyArguments().thenReturn(null);
    User user = new User("test1", "test2", false);
    doThrow(LoginTask.LoginException.class).when(loginTask).loadOffline("test1", "test2");
    loginTask.migrateIfVerified(user);
    verifyNew(MigrateUnverifiedDataToVerified.class, never());
}

@Test
public void bootstrapTest() throws Exception {
    saltOrchestrator.init(parallelOrchestratorComponentRunner, exitCriteria);
    PowerMockito.whenNew(OrchestratorBootstrapRunner.class).withAnyArguments().thenReturn(mock(OrchestratorBootstrapRunner.class));
    PowerMockito.whenNew(SaltBootstrap.class).withAnyArguments().thenReturn(mock(SaltBootstrap.class));
    saltOrchestrator.bootstrap(Collections.singletonList(gatewayConfig), targets, exitCriteriaModel);
    verify(parallelOrchestratorComponentRunner, times(2)).submit(any(OrchestratorBootstrapRunner.class));
    verifyNew(OrchestratorBootstrapRunner.class, times(2)).withArguments(any(PillarSave.class), eq(exitCriteria), eq(exitCriteriaModel), any(), anyInt(), anyInt());
    verifyNew(OrchestratorBootstrapRunner.class, times(2)).withArguments(any(SaltBootstrap.class), eq(exitCriteria), eq(exitCriteriaModel), any(), anyInt(), anyInt());
    verifyNew(SaltBootstrap.class, times(1)).withArguments(eq(saltConnector), eq(Collections.singletonList(gatewayConfig)), eq(targets), eq(".example.com"));
}

@SuppressWarnings("unchecked")
@Test
public void noPackageDiscoveredOnDisk() throws Exception {
    //set all the method call arguments
    String repoName = "testRepo";
    PackageSyncReport mockPackageSyncReport = mock(PackageSyncReport.class);
    Collection<ContentProviderPackageDetails> mockCollection = mock(Collection.class);
    //tell the method story as it happens: mock dependencies and configure
    //those dependencies to get the method under test to completion.
    Configuration mockConfiguration = mock(Configuration.class);
    PropertySimple mockProperty = mock(PropertySimple.class);
    when(mockConfiguration.get("packageSourceEnabled")).thenReturn(mockProperty);
    when(mockConfiguration.get("repoSourceEnabled")).thenReturn(mockProperty);
    when(mockProperty.getBooleanValue()).thenReturn(Boolean.TRUE, Boolean.FALSE);
    final String directoryPath = "mock path";
    when(mockConfiguration.getSimpleValue(eq("rootDirectory"), anyString())).thenReturn(directoryPath);
    when(mockConfiguration.getSimpleValue(eq("packageTypeName"), anyString())).thenReturn("packageTypeName");
    when(mockConfiguration.getSimpleValue(eq("architectureName"), anyString())).thenReturn("architectureName");
    when(mockConfiguration.getSimpleValue(eq("resourceType"), anyString())).thenReturn("resource-type");
    File mockRootFolder = mock(File.class);
    whenNew(File.class).withArguments(directoryPath).thenReturn(mockRootFolder);
    when(mockRootFolder.exists()).thenReturn(true);
    when(mockRootFolder.canRead()).thenReturn(true);
    when(mockRootFolder.isDirectory()).thenReturn(true);
    when(mockCollection.toArray()).thenReturn(new Object[0]);
    File mockRepoFolder = mock(File.class);
    when(mockRootFolder.listFiles()).thenReturn(new File[] { mockRepoFolder });
    when(mockRepoFolder.isDirectory()).thenReturn(true);
    when(mockRepoFolder.getName()).thenReturn(repoName);
    when(mockRepoFolder.listFiles()).thenReturn(new File[0]);
    //create object to test and inject required dependencies
    DiskSource objectUnderTest = new DiskSource();
    //run methods under test
    objectUnderTest.initialize(mockConfiguration);
    objectUnderTest.synchronizePackages(repoName, mockPackageSyncReport, mockCollection);
    //verify the results (Assert and Mock Verification)
    verify(mockPackageSyncReport, never()).addUpdatedPackage(any(ContentProviderPackageDetails.class));
    verify(mockPackageSyncReport, never()).addNewPackage(any(ContentProviderPackageDetails.class));
    verify(mockConfiguration, times(2)).get(anyString());
    verifyNew(File.class).withArguments(directoryPath);
}