Java Code Examples for org.testng.Assert#assertThrows()

/**
 * Test whether Bulkhead is enabled on {@code waitWithBulkhead()}
 *
 * @throws InterruptedException interrupted
 * @throws ExecutionException task was aborted
 */
@Test
public void testBulkhead() throws ExecutionException, InterruptedException {
    ExecutorService executor = Executors.newFixedThreadPool(10);

    // Start two executions at once
    CompletableFuture<Void> waitingFuture = new CompletableFuture<>();
    Future<?> result1 = executor.submit(() -> disableClient.waitWithBulkhead(waitingFuture));
    Future<?> result2 = executor.submit(() -> disableClient.waitWithBulkhead(waitingFuture));

    try {
        disableClient.waitForBulkheadExecutions(2);

        // Try to start a third execution. This would throw a BulkheadException if Bulkhead is enabled.
        // Bulkhead is enabled on the method, so expect exception
        Assert.assertThrows(BulkheadException.class, () -> disableClient.waitWithBulkhead(CompletableFuture.completedFuture(null)));
    }
    finally {
        // Clean up executor and first two executions
        executor.shutdown();

        waitingFuture.complete(null);
        result1.get();
        result2.get();
    }
}
 

@Test
void testGiteaMapping() throws Exception {
  try (SvnTestServer server = createServer(administratorToken, dir -> new GiteaMappingConfig(dir, GitCreateMode.EMPTY))) {
    // Test user can get own private repo
    openSvnRepository(server, testPrivateRepository, user, userPassword).getLatestRevision();
    // Collaborator cannot get test's private repo
    Assert.assertThrows(SVNAuthenticationException.class, () -> openSvnRepository(server, testPrivateRepository, collaborator, collaboratorPassword).getLatestRevision());
    // Anyone can get public repo
    openSvnRepository(server, testPublicRepository, "anonymous", "nopassword").getLatestRevision();
    // Collaborator can get public repo
    openSvnRepository(server, testPublicRepository, collaborator, collaboratorPassword).getLatestRevision();
    // Add collaborator to private repo
    repoAddCollaborator(testPrivateRepository.getOwner().getLogin(), testPrivateRepository.getName(), collaborator);
    // Collaborator can get private repo
    openSvnRepository(server, testPrivateRepository, collaborator, collaboratorPassword).getLatestRevision();
  }
}
 

@Test
public void testGetMappingKey() {
    scenarioMapper.setScenarioList(Arrays.asList(new IssueScenario(),
                                                new FooScenario(),
                                                new GetFooScenario(),
                                                new PutFooScenario(),
                                                new OtherScenario()));

    Assert.assertEquals(scenarioMapper.getMappingKey(new HttpMessage().path("/issues/foo")), "FooScenario");
    Assert.assertEquals(scenarioMapper.getMappingKey(new HttpMessage().path("/issues/foo").method(HttpMethod.GET)), "GetFooScenario");
    Assert.assertEquals(scenarioMapper.getMappingKey(new HttpMessage().path("/issues/foo").method(HttpMethod.PUT)), "PutFooScenario");
    Assert.assertEquals(scenarioMapper.getMappingKey(new HttpMessage().path("/issues/other")), "OtherScenario");
    Assert.assertEquals(scenarioMapper.getMappingKey(new HttpMessage().path("/issues/bar").method(HttpMethod.GET)), "IssueScenario");
    Assert.assertEquals(scenarioMapper.getMappingKey(new HttpMessage().path("/issues/bar").method(HttpMethod.DELETE)), "IssueScenario");
    Assert.assertEquals(scenarioMapper.getMappingKey(new HttpMessage().path("/issues/bar").method(HttpMethod.PUT)), "default");
    Assert.assertEquals(scenarioMapper.getMappingKey(new HttpMessage().path("/issues/bar")), "default");
    Assert.assertEquals(scenarioMapper.getMappingKey(null), "default");

    scenarioMapper.setUseDefaultMapping(false);

    Assert.assertThrows(CitrusRuntimeException.class, () -> scenarioMapper.getMappingKey(new HttpMessage().path("/issues/bar").method(HttpMethod.PUT)));
    Assert.assertThrows(CitrusRuntimeException.class, () -> scenarioMapper.getMappingKey(new HttpMessage().path("/issues/bar")));
    Assert.assertThrows(CitrusRuntimeException.class, () -> scenarioMapper.getMappingKey(null));
}
 

/**
 * failAndRetryOnce is annotated with maxRetries = 1 so it is expected to execute 2 times.
 */
@Test
public void testRetryEnabled() {
    // Always get a TestException
    Assert.assertThrows(TestException.class, () -> disableClient.failAndRetryOnce());
    // Should get two attempts if retry is enabled
    Assert.assertEquals(disableClient.getFailAndRetryOnceCounter(), 2, "Retry enabled - should be 2 executions");
}
 

@Test
public void testDropByKey() {
  Set<String> set = ImmutableSet.of("v1", "v2", "v3");

  DistkvClient client = newDistkvClient();
  client.sets().put("k1", set);
  client.drop("k1");

  // This method will throw a DistkvException if we drop the nonexistent key in store.
  Assert.assertThrows(DistkvException.class,
      () -> client.sets().get("k1"));
  client.disconnect();
}
 

/**
 * Test that a Fallback service is ignored when service fails.
 * 
 * Retry is enabled at the class level and not disabled for this method so we expect to get two executions
 */
@Test
public void testFallbackDisabled() {
    // Throw TestException because Fallback is disabled
    Assert.assertThrows(TestException.class, () -> disableClient.failRetryOnceThenFallback());
    // One execution because Retry is enabled
    Assert.assertEquals(disableClient.getFailRetryOnceThenFallbackCounter(), 2, "Retry enabled - should be 2 executions");
}
 

@Test
public void testDistkvKeyDuplicatedException() {
  distkvClient = newDistkvClient();
  testPut();
  Assert.assertThrows(
      DistkvKeyDuplicatedException.class, this::testPut);
  distkvClient.disconnect();
}
 

@Test
public void testDrop() throws InvalidProtocolBufferException {
  DistkvClient client = newDistkvClient();
  dummyPut(client);
  //Drop expiration.
  client.drop("k1");
  Assert.assertThrows(KeyNotFoundException.class, () -> client.strs().get("k1"));
  client.disconnect();
}
 

@Test(dataProvider = "alleleRemapExamples")
public void testOrderSortAlleles(VariantContext actual, VariantContext expected, boolean shouldSucceed) {
    VCFHeader header = VariantContextTestUtils.getCompleteHeader();

    if (shouldSucceed) {
        VariantContextTestUtils.assertVariantContextsAreEqualAlleleOrderIndependent(actual, expected, Collections.emptyList(), Collections.emptyList(), header);
    } else {
        Assert.assertThrows(AssertionError.class, () -> VariantContextTestUtils.assertVariantContextsAreEqualAlleleOrderIndependent(actual, expected, Collections.emptyList(), Collections.emptyList(), header));
    }
}
 

/**
 * CircuitBreaker is enabled on the method so the policy should be applied
 */
@Test
public void testCircuitBreaker() {
    // Always get TestException on first execution
    Assert.assertThrows(TestException.class, () -> disableClient.failWithCircuitBreaker());
    // Should get CircuitBreakerOpenException on second execution because CircuitBreaker is enabled
    Assert.assertThrows(CircuitBreakerOpenException.class, () -> disableClient.failWithCircuitBreaker());
}
 

@Test
public void testEmptyRubixSite()
{
  Configuration configuration = new Configuration();
  ClusterUtil.rubixSiteExists = new AtomicReference<>();
  rubixSiteXmlName = workingDirectory + "/../rubix-common/src/test/resources/faulty-rubix-site.xml";
  CacheConfig.setRubixSiteLocation(configuration, rubixSiteXmlName);
  Assert.assertThrows(Exception.class, () -> ClusterUtil.applyRubixSiteConfig(configuration));
}
 

/**
 * CircuitBreaker is enabled on the method so the policy should be applied
 */
@Test
public void testCircuitBreaker() {
    // Always get TestException on first execution
    Assert.assertThrows(TestException.class, () -> disableClient.failWithCircuitBreaker());
    // Should get CircuitBreakerOpenException on second execution because CircuitBreaker is enabled
    Assert.assertThrows(CircuitBreakerOpenException.class, () -> disableClient.failWithCircuitBreaker());
}
 

@Test
public void testTableFeatureGetters() {
    final TableFeature feature = new TableFeature(
            new SimpleInterval("1", 10, 100),
            Arrays.asList("1", "2", "3"),
            Arrays.asList("a", "b", "c"));

    // test all values and columns
    Assert.assertEquals(feature.getAllValues(), Arrays.asList("1", "2", "3"));
    Assert.assertEquals(feature.getHeader(), Arrays.asList("a", "b", "c"));

    // test retrieval of all the elements one by one and its mapping
    for (int i = 0; i < 3; i++) {
        final String colName = feature.getHeader().get(i);
        Assert.assertEquals(feature.getValue(i), feature.get(colName));
    }

    // test getValuesTo
    Assert.assertEquals(feature.getValuesTo(1), Arrays.asList("1"));
    Assert.assertEquals(feature.getValuesTo(2), Arrays.asList("1", "2"));

    // test that invalid columns throw an Illegal argument exception
    Assert.assertThrows(IllegalArgumentException.class, () -> feature.getValue(3));
    Assert.assertThrows(IllegalArgumentException.class, () -> feature.getValue(-1));
    Assert.assertThrows(IllegalArgumentException.class, () -> feature.getValuesTo(4));
    Assert.assertThrows(IllegalArgumentException.class, () -> feature.getValuesTo(-1));
}
 

@Test
public void testDrop() {
  DistkvClient client = newDistkvClient();
  client.lists().put("k1", ImmutableList.of("v1", "v2", "v3"));
  client.drop("k1");
  Assert.assertThrows(KeyNotFoundException.class, () -> client.lists().get("k1"));
  client.disconnect();
}
 

@Test
public void testTTLManyKeys() {
  final String command = "ttl k1 k2 k3";
  Assert.assertThrows(DistkvException.class, () -> distkvParser.parse(command));
}
 

@Test
public void testDropWithoutKey() {
  final String command = "drop";
  Assert.assertThrows(DistkvException.class, () -> distkvParser.parse(command));
}
 

/**
 * Test Timeout is enabled, should fail with a timeout exception
 */
@Test
public void testTimeout() {
    // Expect TimeoutException because Timeout is enabled and method will time out
    Assert.assertThrows(TimeoutException.class, () -> disableClient.failWithTimeout());
}
 

/**
 * Test Timeout is enabled, should fail with a timeout exception
 */
@Test
public void testTimeout() {
    // Expect TimeoutException because Timeout is enabled and method will time out
    Assert.assertThrows(TimeoutException.class, () -> disableClient.failWithTimeout());
}
 

/**
 * Test Timeout is enabled, should fail with a timeout exception
 */
@Test
public void testTimeout() {
    // Expect TimeoutException because Timeout is enabled and method will time out
    Assert.assertThrows(TimeoutException.class, () -> disableClient.failWithTimeout());
}
 

/**
 * Test Timeout is disabled, should wait two seconds and then get a TestException
 */
@Test
public void testTimeout() {
    // Expect TestException because Timeout is disabled and will not fire
    Assert.assertThrows(TestException.class, () -> disableClient.failWithTimeout());
}