Exemplo n.º 1
0
  @Test
  public void testOrderClientInvalid() throws Exception {
    NotifyBuilder notify = new NotifyBuilder(context).whenDone(1).create();

    Calendar cal = Calendar.getInstance(Locale.US);
    cal.set(Calendar.YEAR, 2010);
    cal.set(Calendar.MONTH, Calendar.APRIL);
    cal.set(Calendar.DAY_OF_MONTH, 20);
    cal.set(Calendar.HOUR_OF_DAY, 7);
    cal.set(Calendar.MINUTE, 47);
    cal.set(Calendar.SECOND, 58);
    Date date = cal.getTime();

    OrderClient client = new OrderClient("tcp://localhost:61616");
    // when using customer id 999 we force an invalid order
    client.sendOrder(999, date, "5555", "2222");

    boolean matches = notify.matches(5, TimeUnit.SECONDS);
    assertTrue(matches);

    // should be one message in confirm queue
    BrowsableEndpoint be = context.getEndpoint("activemq:queue:invalid", BrowsableEndpoint.class);
    List<Exchange> list = be.getExchanges();
    assertEquals(1, list.size());
    assertEquals("999,2010-04-20T07:47:58,5555,2222", list.get(0).getIn().getBody(String.class));
  }
Exemplo n.º 2
0
  @Test
  public void testOrderClientValid() throws Exception {
    // notify when one message is done
    NotifyBuilder notify = new NotifyBuilder(context).whenDone(1).create();

    // setup order information
    Calendar cal = Calendar.getInstance(Locale.US);
    cal.set(Calendar.YEAR, 2010);
    cal.set(Calendar.MONTH, Calendar.APRIL);
    cal.set(Calendar.DAY_OF_MONTH, 20);
    cal.set(Calendar.HOUR_OF_DAY, 7);
    cal.set(Calendar.MINUTE, 47);
    cal.set(Calendar.SECOND, 58);
    Date date = cal.getTime();

    // send an order using the client
    OrderClient client = new OrderClient("tcp://localhost:61616");
    client.sendOrder(123, date, "4444", "5555");

    // use the notifier to wait for Camel to process the message
    // wait at most 5 seconds to avoid blocking forever if something goes wrong
    boolean matches = notify.matches(5, TimeUnit.SECONDS);
    // true means the notifier condition matched (= 1 message is done)
    assertTrue(matches);

    // should be one message in confirm queue
    BrowsableEndpoint be = context.getEndpoint("activemq:queue:confirm", BrowsableEndpoint.class);
    List<Exchange> list = be.getExchanges();
    assertEquals(1, list.size());
    assertEquals("OK,123,2010-04-20T07:47:58,4444,5555", list.get(0).getIn().getBody(String.class));
  }
  @Test
  public void testWithDonkey() throws Exception {
    // we should have 1 original message + 6 redelivery attempts
    NotifyBuilder notify = new NotifyBuilder(context).whenDone(1).create();

    context.start();

    // there should be 0 row in the database when we start
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookorders", Long.class));

    template.sendBody("activemq:queue:inbox", "Donkey in Action");

    String reply = consumer.receiveBody("activemq:queue:order", 10000, String.class);
    assertNull("There should be no reply", reply);

    // wait for the route to complete
    assertTrue(notify.matches(10, TimeUnit.SECONDS));

    // and then message failed and was moved into the DLQ by the ActiveMQ broker
    reply = consumer.receiveBody("activemq:queue:ActiveMQ.DLQ", 10000, String.class);
    assertNotNull("It should have been moved to DLQ", reply);

    // there should be 0 row in the database with the order
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookorders", Long.class));
    // there should be 1 + 6 redelivery attempt row in the database with the audit-log
    assertEquals(
        Long.valueOf(1),
        jdbc.queryForObject(
            "select count(*) from bookaudit where order_redelivery = 'false'", Long.class));
    assertEquals(
        Long.valueOf(6),
        jdbc.queryForObject(
            "select count(*) from bookaudit where order_redelivery = 'true'", Long.class));

    // print the SQL
    log.info("The following orders was recorded in the orders ...");
    List<Map<String, Object>> rows = jdbc.queryForList("select * from bookorders");
    for (Map<String, Object> row : rows) {
      log.info("Book order[id={}, book={}]", row.get("order_id"), row.get("order_book"));
    }
    log.info("The following orders was recorded in the audit-log ...");
    rows = jdbc.queryForList("select * from bookaudit");
    for (Map<String, Object> row : rows) {
      log.info(
          "Book audit-log[id={}, book={}, redelivery={}]",
          row.get("order_id"),
          row.get("order_book"),
          row.get("order_redelivery"));
    }
  }
  @Test
  public void testBigFile() throws Exception {
    // when the first exchange is done
    NotifyBuilder notify = new NotifyBuilder(context).whenDoneByIndex(0).create();

    long start = System.currentTimeMillis();

    System.out.println("Waiting to be done with 2 min timeout (use ctrl + c to stop)");
    notify.matches(2 * 60, TimeUnit.SECONDS);

    long delta = System.currentTimeMillis() - start;
    System.out.println("Took " + delta / 1000 + " seconds");
  }
  @Test
  public void testRollback() throws Exception {
    // we should keep failing so wait for 5 or more failures
    NotifyBuilder notify = new NotifyBuilder(context).whenFailed(5).create();

    // should take a bit before we process 5 or more, because we use backoff on error
    assertTrue(notify.matches(20, TimeUnit.SECONDS));

    // and there should be 1 rows in the database as we keep rolling back
    int rows = jdbc.queryForObject("select count(*) from partner_metric", Integer.class);
    assertEquals(1, rows);

    context.stop();
  }
  @Test
  public void testWithCamel() throws Exception {
    // we should have 1 original message
    NotifyBuilder notify = new NotifyBuilder(context).whenDone(1).create();

    context.start();

    // there should be 0 row in the database when we start
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookorders", Long.class));
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookaudit", Long.class));

    template.sendBody("activemq:queue:inbox", "Camel in Action");

    // wait for the route to complete
    assertTrue(notify.matches(10, TimeUnit.SECONDS));

    // and the message was sent to the order queue
    String reply = consumer.receiveBody("activemq:queue:order", 10000, String.class);
    assertEquals("Camel in Action", reply);

    // the database need a little sleep time before commits are visible
    Thread.sleep(1000);

    // there should be 1 row in the database with the order, and 0 in the audit-log as it was marked
    // to only rollback
    assertEquals(
        Long.valueOf(1), jdbc.queryForObject("select count(*) from bookorders", Long.class));
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookaudit", Long.class));

    // print the SQL
    log.info("The following orders was recorded in the orders ...");
    List<Map<String, Object>> rows = jdbc.queryForList("select * from bookorders");
    for (Map<String, Object> row : rows) {
      log.info("Book order[id={}, book={}]", row.get("order_id"), row.get("order_book"));
    }
    log.info("The following orders was recorded in the audit-log ...");
    rows = jdbc.queryForList("select * from bookaudit");
    for (Map<String, Object> row : rows) {
      log.info(
          "Book audit-log[id={}, book={}, redelivery={}]",
          row.get("order_id"),
          row.get("order_book"),
          row.get("order_redelivery"));
    }
  }
  public void testRetryUntilRecipientNotFailAndFail() throws Exception {
    invoked.set(0);

    NotifyBuilder event = event().whenDone(1).create();

    getMockEndpoint("mock:result").expectedMessageCount(0);
    getMockEndpoint("mock:foo").expectedMinimumMessageCount(0);

    template.sendBodyAndHeader("seda:start", "Hello World", "recipientListHeader", "not-fail,fail");
    assertMockEndpointsSatisfied();

    // wait until its done before we stop and check that retry was invoked
    boolean matches = event.matches(10, TimeUnit.SECONDS);
    assertTrue(matches);

    context.stop();

    assertEquals(3, invoked.get());
  }
Exemplo n.º 8
0
  @Test
  public void testRouteFileToFile() throws Exception {
    deleteDirectory("target/file2file");
    NotifyBuilder notify =
        new NotifyBuilder(context).from("activemq:queue:hello").whenDone(1).create();

    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedMessageCount(1);

    template.sendBodyAndHeader(
        "file://target/file2file/in", "Hello World", Exchange.FILE_NAME, "hello.txt");

    assertMockEndpointsSatisfied();

    notify.matchesMockWaitTime();

    File file = new File("./target/file2file/out/hello.txt");
    file = file.getAbsoluteFile();
    assertTrue("The file should exists", file.exists());
  }
  private void doSendMessages(int files, int poolSize) throws Exception {
    Mailbox.clearAll();

    NotifyBuilder builder = new NotifyBuilder(context).whenDone(files).create();

    getMockEndpoint("mock:result").expectedMessageCount(files);
    getMockEndpoint("mock:result").expectsNoDuplicates(body());

    final CountDownLatch latch = new CountDownLatch(files);
    ExecutorService executor = Executors.newFixedThreadPool(poolSize);
    for (int i = 0; i < files; i++) {
      final int index = i;
      executor.submit(
          new Callable<Object>() {
            public Object call() throws Exception {
              template.sendBodyAndHeader(
                  "direct:start", "Message " + index, "To", "[email protected]");
              latch.countDown();
              return null;
            }
          });
    }

    // wait first for all the exchanges above to be thoroughly sent asynchronously
    assertTrue(latch.await(5, TimeUnit.SECONDS));

    assertMockEndpointsSatisfied();
    assertTrue(builder.matchesMockWaitTime());

    Mailbox box = Mailbox.get("[email protected]");
    assertEquals(files, box.size());

    // as we use concurrent producers the mails can arrive out of order
    Set<Object> bodies = new HashSet<Object>();
    for (int i = 0; i < files; i++) {
      bodies.add(box.get(i).getContent());
    }

    assertEquals("There should be " + files + " unique mails", files, bodies.size());
    executor.shutdownNow();
  }
Exemplo n.º 10
0
  @Test
  public void testOrderClientFailure() throws Exception {
    // now we expect the message to fail so we use whenFailed
    NotifyBuilder notify = new NotifyBuilder(context).whenFailed(1).create();

    Calendar cal = Calendar.getInstance(Locale.US);
    cal.set(Calendar.YEAR, 2010);
    cal.set(Calendar.MONTH, Calendar.APRIL);
    cal.set(Calendar.DAY_OF_MONTH, 20);
    cal.set(Calendar.HOUR_OF_DAY, 7);
    cal.set(Calendar.MINUTE, 47);
    cal.set(Calendar.SECOND, 58);
    Date date = cal.getTime();

    OrderClient client = new OrderClient("tcp://localhost:61616");
    // by using 9999 as the last item id we force an exception to occur
    client.sendOrder(123, date, "4444", "9999");

    boolean matches = notify.matches(5, TimeUnit.SECONDS);
    assertTrue(matches);
  }
  @Test
  public void testAuditLogFail() throws Exception {
    // we should have 1 original message + 6 redelivery attempts
    NotifyBuilder notify = new NotifyBuilder(context).whenDone(1 + 6).create();

    // simulate the audit-log will fail
    context
        .getRouteDefinition("audit")
        .adviceWith(
            context,
            new AdviceWithRouteBuilder() {
              @Override
              public void configure() throws Exception {
                // simulate error connecting to database
                interceptSendToEndpoint("bean:auditLogService")
                    .skipSendToOriginalEndpoint()
                    .throwException(new IOException("Cannot connect to database"));
              }
            });

    context.start();

    // there should be 0 row in the database when we start
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookorders", Long.class));
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookaudit", Long.class));

    template.sendBody("activemq:queue:inbox", "Camel in Action");

    // wait for the route to complete
    assertTrue(notify.matches(10, TimeUnit.SECONDS));

    // the database need a little sleep time before commits are visible
    Thread.sleep(1000);

    // there should be 0 row in the database with the order
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookorders", Long.class));
    assertEquals(
        Long.valueOf(0), jdbc.queryForObject("select count(*) from bookaudit", Long.class));

    // and then message failed and was moved into the DLQ by the ActiveMQ broker
    String reply = consumer.receiveBody("activemq:queue:ActiveMQ.DLQ", 10000, String.class);
    assertNotNull("It should have been moved to DLQ", reply);

    // print the SQL
    log.info("The following orders was recorded in the orders ...");
    List<Map<String, Object>> rows = jdbc.queryForList("select * from bookorders");
    for (Map<String, Object> row : rows) {
      log.info("Book order[id={}, book={}]", row.get("order_id"), row.get("order_book"));
    }
    log.info("The following orders was recorded in the audit-log ...");
    rows = jdbc.queryForList("select * from bookaudit");
    for (Map<String, Object> row : rows) {
      log.info(
          "Book audit-log[id={}, book={}, redelivery={}]",
          row.get("order_id"),
          row.get("order_book"),
          row.get("order_redelivery"));
    }
  }