public TestWorkflowDataSourceRepository() throws SQLException, FileNotFoundException {
    // set the log levels
    System.setProperty(
        "java.util.logging.config.file",
        new File("./src/main/resources/logging.properties").getAbsolutePath());

    // first load the example configuration
    try {
      System.getProperties().load(new FileInputStream("./src/main/resources/workflow.properties"));
    } catch (Exception e) {
      fail(e.getMessage());
    }

    // get a temp directory
    File tempDir = null;
    File tempFile;

    try {
      tempFile = File.createTempFile("foo", "bar");
      tempFile.deleteOnExit();
      tempDir = tempFile.getParentFile();
    } catch (Exception e) {
      fail(e.getMessage());
    }

    tmpDirPath = tempDir.getAbsolutePath();
  }
  /** For issue #86: https://github.com/elasticsearch/elasticsearch-cloud-aws/issues/86 */
  @Test
  public void testGetDeleteNonExistingSnapshot_86() {
    ClusterAdminClient client = client().admin().cluster();
    logger.info("-->  creating s3 repository without any path");
    PutRepositoryResponse putRepositoryResponse =
        client
            .preparePutRepository("test-repo")
            .setType("s3")
            .setSettings(Settings.settingsBuilder().put("base_path", basePath))
            .get();
    assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));

    try {
      client.prepareGetSnapshots("test-repo").addSnapshots("no-existing-snapshot").get();
      fail("Shouldn't be here");
    } catch (SnapshotMissingException ex) {
      // Expected
    }

    try {
      client.prepareDeleteSnapshot("test-repo", "no-existing-snapshot").get();
      fail("Shouldn't be here");
    } catch (SnapshotMissingException ex) {
      // Expected
    }
  }
Beispiel #3
0
  @Test
  public void testRefCount() throws IOException {
    final ShardId shardId = new ShardId(new Index("index"), 1);
    DirectoryService directoryService = new LuceneManagedDirectoryService(random());
    Store store =
        new Store(
            shardId,
            ImmutableSettings.EMPTY,
            directoryService,
            randomDistributor(directoryService),
            new DummyShardLock(shardId));
    int incs = randomIntBetween(1, 100);
    for (int i = 0; i < incs; i++) {
      if (randomBoolean()) {
        store.incRef();
      } else {
        assertTrue(store.tryIncRef());
      }
      store.ensureOpen();
    }

    for (int i = 0; i < incs; i++) {
      store.decRef();
      store.ensureOpen();
    }

    store.incRef();
    final AtomicBoolean called = new AtomicBoolean(false);
    store.close();
    for (int i = 0; i < incs; i++) {
      if (randomBoolean()) {
        store.incRef();
      } else {
        assertTrue(store.tryIncRef());
      }
      store.ensureOpen();
    }

    for (int i = 0; i < incs; i++) {
      store.decRef();
      store.ensureOpen();
    }

    store.decRef();
    assertThat(store.refCount(), Matchers.equalTo(0));
    assertFalse(store.tryIncRef());
    try {
      store.incRef();
      fail(" expected exception");
    } catch (AlreadyClosedException ex) {

    }
    try {
      store.ensureOpen();
      fail(" expected exception");
    } catch (AlreadyClosedException ex) {

    }
  }
  private static void startXmlRpcWorkflowManager() {
    System.setProperty(
        "java.util.logging.config.file",
        new File("./src/main/resources/logging.properties").getAbsolutePath());

    try {
      System.getProperties().load(new FileInputStream("./src/main/resources/workflow.properties"));
    } catch (Exception e) {
      fail(e.getMessage());
    }
    try {
      luceneCatLoc = Files.createTempDirectory("repo").toString();
      LOG.log(Level.INFO, "Lucene instance repository: [" + luceneCatLoc + "]");
    } catch (Exception e) {
      fail(e.getMessage());
    }

    if (new File(luceneCatLoc).exists()) {
      // blow away lucene cat
      LOG.log(Level.INFO, "Removing workflow instance repository: [" + luceneCatLoc + "]");
      try {
        FileUtils.deleteDirectory(new File(luceneCatLoc));
      } catch (IOException e) {
        fail(e.getMessage());
      }
    }

    System.setProperty(
        "workflow.engine.instanceRep.factory",
        "org.apache.oodt.cas.workflow.instrepo.LuceneWorkflowInstanceRepositoryFactory");
    System.setProperty("org.apache.oodt.cas.workflow.instanceRep.lucene.idxPath", luceneCatLoc);

    try {
      System.setProperty(
          "org.apache.oodt.cas.workflow.repo.dirs",
          "file://" + new File("./src/main/resources/examples").getCanonicalPath());
      System.setProperty(
          "org.apache.oodt.cas.workflow.lifecycle.filePath",
          new File("./src/main/resources/examples/workflow-lifecycle.xml").getCanonicalPath());
    } catch (Exception e) {
      fail(e.getMessage());
    }

    try {
      wmgr = new XmlRpcWorkflowManager(WM_PORT);
      Thread.sleep(MILLIS);
    } catch (Exception e) {
      LOG.log(Level.SEVERE, e.getMessage());
      fail(e.getMessage());
    }
  }
  @Test
  public void should_fail_if_io_error_occurs_when_reading_cql_script() {
    CqlExecCassandraMojo cqlExecCassandraMojo = builder.cqlScript(file("emptyfile.cql")).build();
    mockToThrows(new IOException());

    try {
      cqlExecCassandraMojo.execute();
      fail();
    } catch (MojoExecutionException e) {
      assertEquals("Could not parse or load cql file", e.getMessage());
    } catch (MojoFailureException e) {
      fail(e.getMessage());
    }
  }
  private static void stopXmlRpcWorkflowManager() {
    System.setProperty(
        "java.util.logging.config.file",
        new File("./src/main/resources/logging.properties").getAbsolutePath());

    try {
      System.getProperties().load(new FileInputStream("./src/main/resources/workflow.properties"));
    } catch (Exception e) {
      fail(e.getMessage());
    }
    System.setProperty(
        "workflow.engine.instanceRep.factory",
        "org.apache.oodt.cas.workflow.instrepo.LuceneWorkflowInstanceRepositoryFactory");
    System.setProperty("org.apache.oodt.cas.workflow.instanceRep.lucene.idxPath", luceneCatLoc);

    try {
      System.setProperty(
          "org.apache.oodt.cas.workflow.repo.dirs",
          "file://" + new File("./src/main/resources/examples").getCanonicalPath());
      System.setProperty(
          "org.apache.oodt.cas.workflow.lifecycle.filePath",
          new File("./src/main/resources/examples/workflow-lifecycle.xml").getCanonicalPath());
    } catch (Exception e) {
      fail(e.getMessage());
    }

    try {
      wmgr.shutdown();
    } catch (Exception e) {
      LOG.log(Level.SEVERE, e.getMessage());
      fail(e.getMessage());
    }

    /** Sleep before removing to prevent file not found issues. */
    try {
      Thread.sleep(MILLIS);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    if (new File(luceneCatLoc).exists()) {
      // blow away lucene cat
      LOG.log(Level.INFO, "Removing workflow instance repository: [" + luceneCatLoc + "]");
      try {
        FileUtils.deleteDirectory(new File(luceneCatLoc));
      } catch (IOException e) {
        fail(e.getMessage());
      }
    }
  }
 @Test
 public void testIllegalArgument() {
   try {
     new SpanNotQueryBuilder(null, SpanTermQueryBuilder.PROTOTYPE);
     fail("cannot be null");
   } catch (IllegalArgumentException e) {
     // expected
   }
   try {
     new SpanNotQueryBuilder(SpanTermQueryBuilder.PROTOTYPE, null);
     fail("cannot be null");
   } catch (IllegalArgumentException e) {
     // expected
   }
 }
  @Test
  public void reportsTyposInTaskName() {
    final Task task1 = task("someTask");
    final Task task2 = task("someTasks");
    final Task task3 = task("sometask");
    final Task task4 = task("other");

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName("ssomeTask", true);
            will(returnValue(toSet()));
            one(taskContainer).getAll();
            will(returnValue(toSet(task1, task2)));
            one(subProjectTaskContainer).getAll();
            will(returnValue(toSet(task3, task4)));
          }
        });

    TaskNameResolvingBuildExecuter executer =
        new TaskNameResolvingBuildExecuter(toList("ssomeTask"));
    try {
      executer.select(gradle);
      fail();
    } catch (TaskSelectionException e) {
      assertThat(
          e.getMessage(),
          equalTo(
              "Task 'ssomeTask' not found in [project]. Some candidates are: 'someTask', 'someTasks', 'sometask'."));
    }
  }
  @Test
  public void failsWhenProvidedNameIsAmbiguous() {
    final Task task1 = task("someTask");
    final Task task2 = task("someTasks");

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName("soTa", true);
            will(returnValue(toSet()));
            one(taskContainer).getAll();
            will(returnValue(toSet(task1)));
            one(subProjectTaskContainer).getAll();
            will(returnValue(toSet(task2)));
          }
        });

    TaskNameResolvingBuildExecuter executer = new TaskNameResolvingBuildExecuter(toList("soTa"));
    try {
      executer.select(gradle);
      fail();
    } catch (TaskSelectionException e) {
      assertThat(
          e.getMessage(),
          equalTo(
              "Task 'soTa' is ambiguous in [project]. Candidates are: 'someTask', 'someTasks'."));
    }
  }
  @Test
  public void overloadedNonStandardWriteMethodsOnly_orderB()
      throws IntrospectionException, SecurityException, NoSuchMethodException {
    @SuppressWarnings("unused")
    class C {
      public Object setFoo(int p) {
        return new Object();
      }

      public Object setFoo(String p) {
        return new Object();
      }
    }
    BeanInfo bi = Introspector.getBeanInfo(C.class);

    assertThat(hasReadMethodForProperty(bi, "foo"), is(false));
    assertThat(hasWriteMethodForProperty(bi, "foo"), is(false));

    BeanInfo ebi = new ExtendedBeanInfo(bi);

    assertThat(hasReadMethodForProperty(bi, "foo"), is(false));
    assertThat(hasWriteMethodForProperty(bi, "foo"), is(false));

    assertThat(hasReadMethodForProperty(ebi, "foo"), is(false));
    assertThat(hasWriteMethodForProperty(ebi, "foo"), is(true));

    for (PropertyDescriptor pd : ebi.getPropertyDescriptors()) {
      if (pd.getName().equals("foo")) {
        assertThat(pd.getWriteMethod(), is(C.class.getMethod("setFoo", String.class)));
        return;
      }
    }
    fail("never matched write method");
  }
  @Test
  public void testAliasInvalidFilterValidJson() throws Exception {

    // invalid filter but valid json: put index template works fine, fails during index creation
    client()
        .admin()
        .indices()
        .preparePutTemplate("template_1")
        .setTemplate("te*")
        .addAlias(new Alias("invalid_alias").filter("{ \"invalid\": {} }"))
        .get();

    GetIndexTemplatesResponse response =
        client().admin().indices().prepareGetTemplates("template_1").get();
    assertThat(response.getIndexTemplates().size(), equalTo(1));
    assertThat(response.getIndexTemplates().get(0).getAliases().size(), equalTo(1));
    assertThat(
        response.getIndexTemplates().get(0).getAliases().get("invalid_alias").filter().string(),
        equalTo("{\"invalid\":{}}"));

    try {
      createIndex("test");
      fail(
          "index creation should have failed due to invalid alias filter in matching index template");
    } catch (ElasticsearchIllegalArgumentException e) {
      assertThat(e.getMessage(), equalTo("failed to parse filter for alias [invalid_alias]"));
      assertThat(e.getCause(), instanceOf(QueryParsingException.class));
      assertThat(e.getCause().getMessage(), equalTo("[test] No filter registered for [invalid]"));
    }
  }
  /**
   * Executes batch but finalizer is failed.
   *
   * @throws Exception if failed
   */
  @Test
  public void executeBatch_failed_finalize() throws Exception {
    ProfileBuilder prf = new ProfileBuilder(folder.getRoot());
    prf.setTracker(FinalizerFailed.class);
    ExecutionTask task = prf.task();
    try {
      task.executeBatch("batch");
      fail();
    } catch (IOException e) {
      // ok.
    }

    List<Record> results = SerialExecutionTracker.get(prf.trackingId);
    verifyPhaseOrder(results);

    assertThat(phase(results, "testing", ExecutionPhase.SETUP).size(), is(2));
    assertThat(phase(results, "testing", ExecutionPhase.INITIALIZE).size(), is(1));
    assertThat(phase(results, "testing", ExecutionPhase.IMPORT).size(), is(2));
    assertThat(phase(results, "testing", ExecutionPhase.PROLOGUE).size(), is(1));
    assertThat(phase(results, "testing", ExecutionPhase.MAIN).size(), is(4));
    assertThat(phase(results, "testing", ExecutionPhase.EPILOGUE).size(), is(1));
    assertThat(phase(results, "testing", ExecutionPhase.EXPORT).size(), is(2));
    assertThat(phase(results, "testing", ExecutionPhase.FINALIZE).size(), is(1));
    assertThat(phase(results, "testing", ExecutionPhase.CLEANUP).size(), is(0));

    assertThat(flow(results, "left").size(), is(0));
    assertThat(flow(results, "right").size(), is(0));
    assertThat(flow(results, "last").size(), is(0));
  }
  /** Test case for issue #86: https://github.com/elasticsearch/elasticsearch-cloud-aws/issues/86 */
  @Test
  public void testNonExistingRepo_86() {
    Client client = client();
    logger.info(
        "-->  creating s3 repository with bucket[{}] and path [{}]",
        internalCluster().getInstance(Settings.class).get("repositories.s3.bucket"),
        basePath);
    PutRepositoryResponse putRepositoryResponse =
        client
            .admin()
            .cluster()
            .preparePutRepository("test-repo")
            .setType("s3")
            .setSettings(Settings.settingsBuilder().put("base_path", basePath))
            .get();
    assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));

    logger.info("--> restore non existing snapshot");
    try {
      client
          .admin()
          .cluster()
          .prepareRestoreSnapshot("test-repo", "no-existing-snapshot")
          .setWaitForCompletion(true)
          .execute()
          .actionGet();
      fail("Shouldn't be here");
    } catch (SnapshotMissingException ex) {
      // Expected
    }
  }
  /**
   * This test verifies that the test configuration is set up in a manner that does not make the
   * test {@link #testRepositoryInRemoteRegion()} pointless.
   */
  @Test(expected = RepositoryVerificationException.class)
  public void assertRepositoryInRemoteRegionIsRemote() {
    Client client = client();
    Settings bucketSettings =
        internalCluster().getInstance(Settings.class).getByPrefix("repositories.s3.remote-bucket.");
    logger.info(
        "-->  creating s3 repository with bucket[{}] and path [{}]",
        bucketSettings.get("bucket"),
        basePath);
    client
        .admin()
        .cluster()
        .preparePutRepository("test-repo")
        .setType("s3")
        .setSettings(
            Settings.settingsBuilder()
                .put("base_path", basePath)
                .put("bucket", bucketSettings.get("bucket"))
            // Below setting intentionally omitted to assert bucket is not available in default
            // region.
            //                        .put("region", privateBucketSettings.get("region"))
            )
        .get();

    fail("repository verification should have raise an exception!");
  }
  void checkBulkAction(boolean indexShouldBeAutoCreated, BulkRequestBuilder builder) {
    // bulk operation do not throw MasterNotDiscoveredException exceptions. The only test that auto
    // create kicked in and failed is
    // via the timeout, as bulk operation do not wait on blocks.
    TimeValue timeout;
    if (indexShouldBeAutoCreated) {
      // we expect the bulk to fail because it will try to go to the master. Use small timeout and
      // detect it has passed
      timeout = new TimeValue(200);
    } else {
      // the request should fail very quickly - use a large timeout and make sure it didn't pass...
      timeout = new TimeValue(5000);
    }
    builder.setTimeout(timeout);
    long now = System.currentTimeMillis();
    try {
      builder.get();
      fail("Expected ClusterBlockException");
    } catch (ClusterBlockException e) {

      if (indexShouldBeAutoCreated) {
        // timeout is 200
        assertThat(System.currentTimeMillis() - now, greaterThan(timeout.millis() - 50));
        assertThat(e.status(), equalTo(RestStatus.SERVICE_UNAVAILABLE));
      } else {
        // timeout is 5000
        assertThat(System.currentTimeMillis() - now, lessThan(timeout.millis() - 50));
      }
    }
  }
  @Test
  public void testBrokenMapping() throws Exception {
    // clean all templates setup by the framework.
    client().admin().indices().prepareDeleteTemplate("*").get();

    // check get all templates on an empty index.
    GetIndexTemplatesResponse response = client().admin().indices().prepareGetTemplates().get();
    assertThat(response.getIndexTemplates(), empty());

    client()
        .admin()
        .indices()
        .preparePutTemplate("template_1")
        .setTemplate("te*")
        .addMapping("type1", "abcde")
        .get();

    response = client().admin().indices().prepareGetTemplates().get();
    assertThat(response.getIndexTemplates(), hasSize(1));
    assertThat(response.getIndexTemplates().get(0).getMappings().size(), equalTo(1));
    assertThat(
        response.getIndexTemplates().get(0).getMappings().get("type1").string(), equalTo("abcde"));

    try {
      createIndex("test");
      fail("create index should have failed due to broken index templates mapping");
    } catch (ElasticsearchParseException e) {
      // everything fine
    }
  }
  @Test
  public void failsWhenUnknownTaskNameIsProvided() {
    final Task task1 = task("t1");
    final Task task2 = task("t2");

    context.checking(
        new Expectations() {
          {
            one(project).getTasksByName("b3", true);
            will(returnValue(toSet()));
            one(taskContainer).getAll();
            will(returnValue(toSet(task1, task2)));
            one(subProjectTaskContainer).getAll();
            will(returnValue(toSet()));
          }
        });

    BuildExecuter executer = new TaskNameResolvingBuildExecuter(toList("b3"));
    try {
      executer.select(gradle);
      fail();
    } catch (TaskSelectionException e) {
      assertThat(e.getMessage(), equalTo("Task 'b3' not found in [project]."));
    }
  }
  @Test
  @SuppressWarnings("unchecked")
  public void testDoWithRetry_ReadTimeOut() throws Exception {
    AmazonElasticMapReduceCustomClient client =
        new AmazonElasticMapReduceCustomClient("dummy", "dummy");
    client.setRequestInterval(100);

    Callable callable = mock(Callable.class);
    AmazonClientException exception =
        new AmazonClientException("Unable to execute HTTP request: Read timed out");
    when(callable.call()).thenThrow(exception, exception, exception).thenReturn(new Object());

    long startTime = System.currentTimeMillis();
    Object result = client.doThrottleSafe(callable);
    assertNotNull(result);
    assertThat(
        (System.currentTimeMillis() - startTime),
        greaterThanOrEqualTo(3 * client.getRequestInterval()));

    // now exceed retries
    client.setMaxRetriesOnConnectionErrors(2);
    when(callable.call()).thenThrow(exception, exception, exception).thenReturn(new Object());
    try {
      client.doThrottleSafe(callable);
      fail("should throw exception");
    } catch (Exception e) {
      assertSame(exception, e);
    }
  }
  /**
   * Lock provider for batch.
   *
   * @throws Exception if failed
   */
  @Test
  public void batch() throws Exception {
    Map<String, String> conf = new HashMap<>();
    conf.put(BasicLockProvider.KEY_DIRECTORY, folder.getRoot().getAbsolutePath());
    conf.put(ExecutionLockProvider.KEY_SCOPE, ExecutionLock.Scope.BATCH.getSymbol());

    ServiceProfile<ExecutionLockProvider> profile =
        new ServiceProfile<>(
            "testing",
            BasicLockProvider.class,
            conf,
            ProfileContext.system(getClass().getClassLoader()));
    ExecutionLockProvider instance1 = profile.newInstance();
    ExecutionLockProvider instance2 = profile.newInstance();

    try (ExecutionLock lock = instance1.newInstance("batch1")) {
      lock.beginFlow("flow1", "exec1");
      try {
        instance2.newInstance("batch1");
        fail("cannot run same batch");
      } catch (IOException e) {
        // ok.
      }
      try (ExecutionLock other = instance2.newInstance("batch2")) {
        // can acquire any flow/exec lock
        other.beginFlow("flow2", "exec1");
        other.endFlow("flow2", "exec1");
        other.beginFlow("flow1", "exec2");
        other.endFlow("flow1", "exec2");
        other.beginFlow("flow2", "exec2");
        other.endFlow("flow2", "exec2");
      }
    }
  }
Beispiel #20
0
  /**
   * Tries to create payment against review invoice. Here, instead of using the billing process to
   * generate a review invoice we are creating a review invoice with the help of saveLegacyInvoice
   * call.
   */
  @Test
  public void testPayReviewInvoice() {
    // creating new user
    UserWS user = buildUser(PRANCING_PONY_ACCOUNT_TYPE);
    user.setId(api.createUser(user));

    ItemTypeWS itemType = buildItemType();
    itemType.setId(api.createItemCategory(itemType));

    ItemDTOEx item = buildItem(itemType.getId(), api.getCallerCompanyId());
    item.setId(api.createItem(item));

    InvoiceWS invoice = buildInvoice(user.getId(), item.getId());
    invoice.setIsReview(Integer.valueOf(1));
    invoice.setId(api.saveLegacyInvoice(invoice));

    // check if invoice is a review invoice
    System.out.println("Invoice is review : " + invoice.getIsReview());
    assertEquals("Invoice is a review invoice", Integer.valueOf(1), invoice.getIsReview());

    try {
      // pay for a review invoice
      api.payInvoice(invoice.getId());
      fail("We should not be able to issue a payment against review invoice");
    } catch (SessionInternalError e) {
      System.out.println(e.getMessage());
    }

    // clean up
    api.deleteInvoice(invoice.getId());
    api.deleteItem(item.getId());
    api.deleteItemCategory(itemType.getId());
    api.deleteUser(user.getId());
  }
 private void runTestWithForbiddenName(String name) throws IOException {
   try {
     pluginManager(null).removePlugin(name);
     fail("this plugin name [" + name + "] should not be allowed");
   } catch (ElasticsearchIllegalArgumentException e) {
     // We expect that error
   }
 }
 private void mockToThrows(Throwable throwable) {
   try {
     mockStatic(IOUtil.class);
     when(IOUtil.toString(any(FileReader.class))).thenThrow(throwable);
   } catch (IOException e) {
     fail(e.getMessage());
   }
 }
 @Test
 public void getByPathFailsForUnknownTask() {
   try {
     container.getByPath("unknown");
     fail();
   } catch (UnknownTaskException e) {
     assertThat(e.getMessage(), equalTo("Task with path 'unknown' not found in <project>."));
   }
 }
  @Test
  public void should_fail_if_file_not_found_occurs_when_reading_cql_script() {
    CqlExecCassandraMojo cqlExecCassandraMojo = builder.cqlScript(file("emptyfile.cql")).build();
    mockToThrows(new FileNotFoundException());

    try {
      cqlExecCassandraMojo.execute();
      fail();
    } catch (MojoExecutionException e) {
      assertThat(
          e.getMessage(),
          allOf(
              startsWith("Cql file '"),
              endsWith("emptyfile.cql' was deleted before I could read it")));
    } catch (MojoFailureException e) {
      fail(e.getMessage());
    }
  }
  @Test
  public void should_fail_when_request_fails() {
    CqlExecCassandraMojo cqlExecCassandraMojo = builder.cqlStatement(CQL_STATEMENT).build();
    mockThriftExecutionWith(
        new ThrowsException(
            new ThriftApiExecutionException(new InvalidRequestException("bad statement"))));

    try {
      cqlExecCassandraMojo.execute();
      fail();
    } catch (MojoExecutionException e) {
      assertEquals(
          "There was a problem calling Apache Cassandra's Thrift API. Details: The request was not properly formatted bad statement",
          e.getMessage());
    } catch (MojoFailureException e) {
      fail(e.getMessage());
    }
  }
 @Test
 public void testCreateInstanceWithoutHttpHandler() throws Exception {
   try {
     new RestfitClient.Builder().userAgent("RestfitTest/1.0").build();
     fail("never reached");
   } catch (IllegalArgumentException e) {
     assertThat(e.getMessage(), is("No httpStack specified"));
   }
 }
 @Test
 public void testCreateInstanceWithoutUserAgent() throws Exception {
   try {
     new RestfitClient.Builder().httpStack(new DummyHttpStack()).build();
     fail("never reached");
   } catch (IllegalArgumentException e) {
     assertThat(e.getMessage(), is("No userAgent specified"));
   }
 }
 private static void assertCanCreateWritableFile(File destination) throws IOException {
   boolean createdFreshFile = destination.createNewFile();
   if (createdFreshFile) {
     try {
       if (destination.canWrite()) {
         try (FileWriter writer = new FileWriter(destination)) {
           writer.append("dummy test output");
         }
       } else {
         fail(String.format("Cannot write to %s", destination));
       }
     } finally {
       destination.delete();
     }
   } else {
     fail(String.format("Cannot create file: %s", destination));
   }
 }
Beispiel #29
0
 @Test
 public void parseShouldRejectChecksumFailure() {
   try {
     IBAN.parse(INVALID_IBAN);
     fail("Invalid input should have been rejected for checksum mismatch.");
   } catch (WrongChecksumException e) {
     assertThat(e.getFailedInput(), is(INVALID_IBAN));
   }
 }
 /**
  * Attempts to convert profile without retry count.
  *
  * @throws Exception if failed
  */
 @Test
 public void convert_count_unknown() throws Exception {
   ProcessProfile profile = profile(KEY_COMPONENT, DummyProcess.class.getName());
   try {
     RetryableProcessProfile.convert(profile);
     fail();
   } catch (IllegalArgumentException e) {
     // ok.
   }
 }