@Test
  public void sendLongSubmitSM() throws Exception {
    result.expectedMessageCount(2);

    Exchange exchange = start.createExchange(ExchangePattern.InOnly);
    exchange
        .getIn()
        .setBody(
            "Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! "
                + "Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! "
                + "Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! "); // 270 chars

    template.send(start, exchange);

    assertMockEndpointsSatisfied();
    assertEquals(
        SmppMessageType.DeliveryReceipt.toString(),
        result.getExchanges().get(0).getIn().getHeader(SmppConstants.MESSAGE_TYPE));
    assertEquals(
        SmppMessageType.DeliveryReceipt.toString(),
        result.getExchanges().get(1).getIn().getHeader(SmppConstants.MESSAGE_TYPE));

    assertNotNull(exchange.getIn().getHeader(SmppConstants.ID));
    assertEquals(2, exchange.getIn().getHeader(SmppConstants.SENT_MESSAGE_COUNT));
  }
  /**
   * Test multi dir.
   *
   * @throws Exception the exception
   */
  @Test
  public void testMultiDir() throws Exception {
    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedBodiesReceived("Bye World", "Hello World", "Goodday World");

    assertMockEndpointsSatisfied();

    Exchange exchange = mock.getExchanges().get(0);
    RemoteFile<?> file = (RemoteFile<?>) exchange.getProperty(FileComponent.FILE_EXCHANGE_FILE);
    assertNotNull(file);
    assertDirectoryEquals("webdav/multidir/bye.txt", file.getAbsoluteFilePath());
    assertDirectoryEquals("bye.txt", file.getRelativeFilePath());
    assertEquals("bye.txt", file.getFileName());

    exchange = mock.getExchanges().get(1);
    file = (RemoteFile<?>) exchange.getProperty(FileComponent.FILE_EXCHANGE_FILE);
    assertNotNull(file);
    assertDirectoryEquals("webdav/multidir/sub/hello.txt", file.getAbsoluteFilePath());
    assertDirectoryEquals("sub/hello.txt", file.getRelativeFilePath());
    assertEquals("sub/hello.txt", file.getFileName());
    assertEquals("hello.txt", file.getFileNameOnly());

    exchange = mock.getExchanges().get(2);
    file = (RemoteFile<?>) exchange.getProperty(FileComponent.FILE_EXCHANGE_FILE);
    assertNotNull(file);
    assertDirectoryEquals("webdav/multidir/sub/sub2/godday.txt", file.getAbsoluteFilePath());
    assertDirectoryEquals("sub/sub2/godday.txt", file.getRelativeFilePath());
    assertEquals("sub/sub2/godday.txt", file.getFileName());
    assertEquals("godday.txt", file.getFileNameOnly());
  }
  @Test
  /** Operation: DELETE Body contains: 12345678900987654321abcdeffedcba */
  public void testDeleteWithIngestException() throws Exception {
    resetMocks();

    // Setup expectations to verify
    final MockEndpoint mockVerifierEndpoint = getMockEndpoint("mock:result");
    mockVerifierEndpoint.expectedMessageCount(1);

    final List<Metacard> metacards = new ArrayList<Metacard>();
    metacards.add(metacard1);

    // setup mock catalog framework
    final String[] metacardIds = new String[metacards.size()];
    for (int i = 0; i < metacards.size(); i++) {
      metacardIds[i] = metacards.get(i).getId();
    }

    DeleteRequest deleteRequest = new DeleteRequestImpl(metacardIds);
    DeleteResponse deleteResponse = new DeleteResponseImpl(deleteRequest, new HashMap(), metacards);
    when(catalogFramework.delete(any(DeleteRequest.class))).thenThrow(new IngestException());

    // Exercise the route with a DELETE operation
    template.sendBodyAndHeader("direct:sampleInput", metacardIds, "Operation", "DELETE");

    // Verify that the number of metacards in the exchange after the records
    // is identical to the input
    assertListSize(mockVerifierEndpoint.getExchanges(), 1);
    final Exchange exchange = mockVerifierEndpoint.getExchanges().get(0);
    final List<Update> cardsDeleted = (List<Update>) exchange.getIn().getBody();
    assertListSize(cardsDeleted, 0);

    mockVerifierEndpoint.assertIsSatisfied();
  }
  @Test
  /** Operation: CREATE Body contains: Metacard */
  public void testCreateWithIngestException() throws Exception {
    resetMocks();

    // Setup expectations to verify
    final MockEndpoint mockVerifierEndpoint = getMockEndpoint("mock:result");
    mockVerifierEndpoint.expectedMessageCount(1);

    final List<Metacard> metacards = new ArrayList<Metacard>();
    metacards.add(metacard1);

    // Mock catalog framework
    final CreateRequest createRequest = new CreateRequestImpl(metacards);
    final CreateResponse createResponse =
        new CreateResponseImpl(createRequest, new HashMap(), metacards);
    when(catalogFramework.create(any(CreateRequest.class))).thenThrow(new IngestException());

    // Exercise the route with a CREATE operation
    template.sendBodyAndHeader("direct:sampleInput", metacard1, "Operation", "CREATE");

    // Verify that the number of metacards in the exchange after the records
    // is identical to the input
    assertListSize(mockVerifierEndpoint.getExchanges(), 1);
    final Exchange exchange = mockVerifierEndpoint.getExchanges().get(0);
    final List<Metacard> cardsCreated = (List<Metacard>) exchange.getIn().getBody();
    assertListSize(cardsCreated, 0);

    mockVerifierEndpoint.assertIsSatisfied();
  }
  public void testDuplicateMessagesAreFilteredOut() throws Exception {
    assertEquals(0, repo.getExchange().size());

    context.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() throws Exception {
            from("direct:start").idempotentConsumer(header("messageId"), repo).to("mock:result");
          }
        });
    context.start();

    resultEndpoint.expectedBodiesReceived("one", "two", "three");

    sendMessage("1", "one");
    sendMessage("2", "two");
    sendMessage("1", "one");
    sendMessage("2", "two");
    sendMessage("1", "one");
    sendMessage("3", "three");

    assertMockEndpointsSatisfied();

    // we used 6 different exchanges
    assertEquals(6, repo.getExchange().size());

    for (Exchange exchange : resultEndpoint.getExchanges()) {
      // should be in repo list
      assertTrue(
          "Should contain the exchange", repo.getExchange().contains(exchange.getExchangeId()));
    }
  }
  @Test
  public void testHeaderAndTrailer() throws Exception {
    results.expectedMessageCount(1);
    results.message(0).body().isInstanceOf(List.class);
    results.message(0).header("camelFlatpackCounter").isEqualTo(6);

    results.assertIsSatisfied();

    List<Map<String, String>> data =
        CastUtils.cast(results.getExchanges().get(0).getIn().getBody(List.class));

    // assert header
    Map<String, String> header = data.get(0);
    assertEquals("HBT", header.get("INDICATOR"));
    assertEquals("20080817", header.get("DATE"));

    // assert body
    int counter = 0;
    for (Map<String, String> row : data.subList(1, 5)) {
      assertEquals("FIRSTNAME", expectedFirstName[counter], row.get("FIRSTNAME"));
      LOG.info("Result: " + counter + " = " + row);
      counter++;
    }

    // assert trailer
    Map<String, String> trailer = data.get(5);
    assertEquals("FBT", trailer.get("INDICATOR"));
    assertEquals("SUCCESS", trailer.get("STATUS"));
  }
  @Test
  public void testSendMessageToPartner() throws Exception {

    mockAgreement1.setExpectedMessageCount(1);
    mockAgreement2.setExpectedMessageCount(1);
    mockUpdateMessageStore.setExpectedMessageCount(4);
    mockEbmsResponseInbound.setExpectedMessageCount(1);
    mockEbmsResponseInbound.expectedBodiesReceived(
        IOUtils.toString(new FileInputStream(fileFromClasspath("simple-as4-receipt.xml"))));
    mockEbmsResponseInbound.expectedHeaderReceived(
        EbmsConstants.CONTENT_TYPE, EbmsConstants.SOAP_XML_CONTENT_TYPE);
    mockEbmsResponseInbound.expectedHeaderReceived(Exchange.HTTP_METHOD, "POST");

    sendMessage(
        "agreement1",
        "simple-as4-user-message.txt",
        "Multipart/Related; boundary=\"----=_Part_7_10584188.1123489648993\"; type=\"application/soap+xml\"; start=\"<*****@*****.**>\"",
        "*****@*****.**",
        MessageType.USER_MESSAGE);

    sendMessage(
        "agreement2",
        "simple-as4-receipt.xml",
        EbmsConstants.SOAP_XML_CONTENT_TYPE,
        "*****@*****.**",
        MessageType.SIGNAL_MESSAGE_WITH_USER_MESSAGE);

    assertMockEndpointsSatisfied();

    Exchange e = mockEbmsResponseInbound.getExchanges().get(0);
    assertThat(e.getIn().getHeaders().values(), hasSize(3));
  }
  public void testSimpleSplitWriteRead() throws Exception {
    context.addRoutes(
        new RouteBuilder() {
          @Override
          public void configure() {
            from("direct:start")
                .to(
                    "hdfs://localhost:9000/tmp/test/test-camel-simple-write-file?fileSystemType=HDFS&splitStrategy=BYTES:5,IDLE:1000");
            from("hdfs://localhost:9000/tmp/test/test-camel-simple-write-file?pattern=seg*&initialDelay=2000&fileSystemType=HDFS&chunkSize=5")
                .to("mock:result");
          }
        });
    context.start();

    for (int i = 0; i < 10; ++i) {
      template.sendBody("direct:start", "CIAO" + i);
    }

    MockEndpoint resultEndpoint = (MockEndpoint) context.getEndpoint("mock:result");

    resultEndpoint.expectedMessageCount(10);
    resultEndpoint.assertIsSatisfied();

    int i = 0;
    List<Exchange> exchanges = resultEndpoint.getExchanges();
    for (Exchange exchange : exchanges) {
      Assert.assertEquals("CIAO" + i++, exchange.getIn().getBody(String.class));
    }
  }
  @Test
  public void sendSubmitSMInOnly() throws Exception {
    result.expectedMessageCount(1);

    Exchange exchange = start.createExchange(ExchangePattern.InOnly);
    exchange.getIn().setBody("Hello SMPP World!");

    template.send(start, exchange);

    assertMockEndpointsSatisfied();
    Exchange resultExchange = result.getExchanges().get(0);
    assertEquals(
        SmppMessageType.DeliveryReceipt.toString(),
        resultExchange.getIn().getHeader(SmppConstants.MESSAGE_TYPE));
    assertEquals("Hello SMPP World!", resultExchange.getIn().getBody());
    assertNotNull(resultExchange.getIn().getHeader(SmppConstants.ID));
    assertEquals(1, resultExchange.getIn().getHeader(SmppConstants.SUBMITTED));
    assertEquals(1, resultExchange.getIn().getHeader(SmppConstants.DELIVERED));
    assertNotNull(resultExchange.getIn().getHeader(SmppConstants.DONE_DATE));
    assertNotNull(resultExchange.getIn().getHeader(SmppConstants.SUBMIT_DATE));
    assertNull(resultExchange.getIn().getHeader(SmppConstants.ERROR));

    assertNotNull(exchange.getIn().getHeader(SmppConstants.ID));
    assertEquals(1, exchange.getIn().getHeader(SmppConstants.SENT_MESSAGE_COUNT));
  }
  public void testXPathWithNamespaceDifferentNamespace() throws Exception {
    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedBodiesReceived("<number xmlns=\"http://acme.com/cake\">55</number>");

    template.sendBody("direct:in", "<number xmlns=\"http://acme.com/cake\">55</number>");

    mock.assertIsSatisfied();
    Assert.assertNull(mock.getExchanges().get(0).getIn().getHeader("foo"));
  }
 @Test
 public void testDefault() throws Exception {
   mock.expectedBodiesReceived("test1");
   mock.expectedHeaderReceived("test", "test2");
   producerTemplate.sendBodyAndHeader("direct:input", "test1", "test", "test2");
   mock.assertIsSatisfied();
   Message received = mock.getExchanges().get(0).getIn();
   assertEquals("default", received.getHeader(GTaskBinding.GTASK_QUEUE_NAME));
   assertEquals(0, received.getHeader(GTaskBinding.GTASK_RETRY_COUNT));
 }
  @Test
  public void testNoFeedInHeader() throws Exception {
    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedMessageCount(1);
    mock.assertIsSatisfied();

    Exchange exchange = mock.getExchanges().get(0);
    Message in = exchange.getIn();
    assertNotNull(in);
    assertNull(in.getHeader(RssConstants.RSS_FEED));
  }
  public void testEcho() throws Exception {
    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedBodiesReceived("echo Hello World");

    template.sendBody("direct:echo", "Hello World");

    assertMockEndpointsSatisfied();
    assertNull(
        "There should no Bean_METHOD_NAME header",
        mock.getExchanges().get(0).getIn().getHeader(Exchange.BEAN_METHOD_NAME));
  }
 @Test
 public void testEndpointWithoutHttps() {
   mockEndpoint.reset();
   try {
     template.sendBodyAndHeader(
         "http://localhost:" + port + "/test", expectedBody, "Content-Type", "application/xml");
     fail("expect exception on access to https endpoint via http");
   } catch (RuntimeCamelException expected) {
   }
   assertTrue("mock endpoint was not called", mockEndpoint.getExchanges().isEmpty());
 }
  @Test
  public void test() throws Exception {
    deleteDirectory("target/smooks");
    template.sendBody("file://target/smooks", "<blah />");

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

    assertMockEndpointsSatisfied();

    assertEquals("<blah />", mock.getExchanges().get(0).getIn().getBody(String.class));
  }
Example #16
0
 @Test
 public void testOnline() throws InterruptedException {
   // Wait for 5 seconds while Camel route is exercised
   resultEndpoint.whenAnyExchangeReceived(null);
   Thread.sleep(5000);
   // Ensure online symptoms are reported
   List<Exchange> exchanges = resultEndpoint.getExchanges();
   Assert.assertTrue(!exchanges.isEmpty());
   Assert.assertEquals(1, alerts);
   Assert.assertEquals(exchanges.size(), builder.getPingProcessor().getSucceeded());
   Assert.assertEquals(0, builder.getPingProcessor().getFailed());
   Assert.assertEquals(exchanges.size(), builder.getPingProcessor().getTotal());
 }
Example #17
0
  public void testSortReverse() throws Exception {
    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedMessageCount(1);

    template.sendBody("direct:reverse", "Hadrian,William,Claus");

    assertMockEndpointsSatisfied();

    List<?> list = mock.getExchanges().get(0).getIn().getBody(List.class);
    assertEquals("William", list.get(0));
    assertEquals("Hadrian", list.get(1));
    assertEquals("Claus", list.get(2));
  }
  @Test
  /** Operation: UPDATE Body contains: Metacard */
  public void testUpdateWithSingleMetacard() throws Exception {
    resetMocks();

    // Setup expectations to verify
    final MockEndpoint mockVerifierEndpoint = getMockEndpoint("mock:result");
    mockVerifierEndpoint.expectedMessageCount(1);

    final List<Metacard> metacards = new ArrayList<Metacard>();
    metacards.add(metacard1);

    // setup mock catalog framework
    final Update update = new UpdateImpl(metacard1, metacard2);
    List<Update> updates = new ArrayList<Update>();
    updates.add(update);

    final String[] metacardIds = new String[metacards.size()];
    for (int i = 0; i < metacards.size(); i++) {
      metacardIds[i] = metacards.get(i).getId();
    }

    UpdateRequest updateRequest = new UpdateRequestImpl(metacardIds, metacards);
    UpdateResponse updateResponse = new UpdateResponseImpl(updateRequest, new HashMap(), updates);
    when(catalogFramework.update(any(UpdateRequest.class))).thenReturn(updateResponse);

    // Exercise the route with a UPDATE operation
    template.sendBodyAndHeader("direct:sampleInput", metacard1, "Operation", "UPDATE");

    // Verify that the number of metacards in the exchange after the records
    // is identical to the input
    assertListSize(mockVerifierEndpoint.getExchanges(), 1);
    final Exchange exchange = mockVerifierEndpoint.getExchanges().get(0);
    final List<Update> cardsUpdated = (List<Update>) exchange.getIn().getBody();
    assertListSize(cardsUpdated, 1);

    mockVerifierEndpoint.assertIsSatisfied();
  }
  private void testAttributes(String mockEndpoint, String prefix) throws Exception {
    MockEndpoint mock = getMockEndpoint(mockEndpoint);
    mock.expectedMessageCount(1);
    mock.message(0).header("CamelFileExtendedAttributes").isNotNull();
    mock.message(0).header("CamelFileExtendedAttributes").convertTo(Map.class);
    assertMockEndpointsSatisfied();

    Map<String, Object> attributes =
        mock.getExchanges().get(0).getIn().getHeader("CamelFileExtendedAttributes", Map.class);
    assertNotNull(attributes);
    assertFalse(attributes.isEmpty());
    for (Map.Entry<String, Object> entry : attributes.entrySet()) {
      assertTrue(entry.getKey().startsWith(prefix));
    }
  }
  @Test
  public void shouldLookupBeanByTypeAndInjectFields() throws InterruptedException {
    resultEndpoint.expectedMessageCount(1);
    template.sendBody("direct:injectByType", "hello");

    assertMockEndpointsSatisfied();

    Exchange exchange = resultEndpoint.getExchanges().get(0);
    List<?> results = exchange.getIn().getBody(List.class);
    List<Item> expected = itemsExpected();
    assertNotNull(results);
    assertNotNull(expected);
    assertEquals(expected.size(), results.size());
    assertEquals(expected, results);
  }
  @Test
  public void testUnMarshallingJsonComplete() throws InterruptedException, IOException {
    out.setExpectedMessageCount(1);
    String s = readFile(NOTIFICATION_JSON, Charset.defaultCharset());
    in.sendBody(s);
    out.await(5, TimeUnit.SECONDS);
    out.assertIsSatisfied();
    List<Exchange> exchanges = out.getExchanges();

    for (Exchange exchange : exchanges) {
      Message message = exchange.getIn();
      Notification notif = message.getBody(Notification.class);
      validateNotification(notif);
    }
  }
  /**
   * You get three keys with the UserId "keyflag", a primary key and its two sub-keys. The sub-key
   * with KeyFlag {@link KeyFlags#SIGN_DATA} should be used for signing and the sub-key with KeyFlag
   * {@link KeyFlags#ENCRYPT_COMMS} or {@link KeyFlags#ENCRYPT_COMMS} or {@link
   * KeyFlags#ENCRYPT_STORAGE} should be used for decryption.
   *
   * @throws Exception
   */
  @Test
  public void testKeyFlagSelectsCorrectKey() throws Exception {
    MockEndpoint mockKeyFlag = getMockEndpoint("mock:encrypted_keyflag");
    mockKeyFlag.setExpectedMessageCount(1);
    template.sendBody("direct:keyflag", "Test Message");
    assertMockEndpointsSatisfied();

    List<Exchange> exchanges = mockKeyFlag.getExchanges();
    assertEquals(1, exchanges.size());
    Exchange exchange = exchanges.get(0);
    Message inMess = exchange.getIn();
    assertNotNull(inMess);
    // must contain exactly one encryption key and one signature
    assertEquals(1, inMess.getHeader(PGPDataFormat.NUMBER_OF_ENCRYPTION_KEYS));
    assertEquals(1, inMess.getHeader(PGPDataFormat.NUMBER_OF_SIGNING_KEYS));
  }
 @Test
 public void testTranslatedEvent() throws Exception {
   out.expectedMinimumMessageCount(1);
   trap.send();
   out.assertIsSatisfied();
   List<Exchange> exchanges = out.getExchanges();
   Exchange exchange = exchanges.get(0);
   Message message = exchange.getIn();
   RawEvent event = message.getBody(RawEvent.class);
   assertNotNull("check for not null", event);
   assertEquals("check event title", "linkDown trap received from 127.0.0.1", event.getTitle());
   assertEquals("check event message", "Received linkDown trap", event.getMessage());
   Map<String, Object> properties = event.getProperties();
   assertEquals("check trap property", "Host has been restarted", properties.get("linkDown"));
   assertEquals("check uptime property", "7:12:00.00", properties.get("sysUpTimeInstance"));
   assertEquals("check description property", "Test Trap!", properties.get("sysDescr.0"));
 }
Example #24
0
  @Test
  public void getAllContentFromServerOrderedFromRootToLeaves() throws Exception {
    resultEndpoint.expectedMessageCount(5);

    Consumer treeBasedConsumer = createConsumerFor(getUrl());
    treeBasedConsumer.start();

    resultEndpoint.assertIsSatisfied();
    treeBasedConsumer.stop();

    List<Exchange> exchanges = resultEndpoint.getExchanges();
    assertTrue(getNodeNameForIndex(exchanges, 0).equals("RootFolder"));
    assertTrue(getNodeNameForIndex(exchanges, 1).equals("Folder1"));
    assertTrue(getNodeNameForIndex(exchanges, 2).equals("Folder2"));
    assertTrue(getNodeNameForIndex(exchanges, 3).contains(".txt"));
    assertTrue(getNodeNameForIndex(exchanges, 4).contains(".txt"));
  }
 public static void checkThrownException(
     MockEndpoint mock,
     Class<? extends Exception> cl,
     Class<? extends Exception> expectedCauseClass,
     String expectedMessagePart)
     throws Exception {
   Exception e = (Exception) mock.getExchanges().get(0).getProperty(Exchange.EXCEPTION_CAUGHT);
   assertNotNull("Expected excpetion " + cl.getName() + " missing", e);
   if (e.getClass() != cl) {
     String stackTrace = getStrackTrace(e);
     fail(
         "Exception  "
             + cl.getName()
             + " excpected, but was "
             + e.getClass().getName()
             + ": "
             + stackTrace);
   }
   if (expectedMessagePart != null) {
     if (e.getMessage() == null) {
       fail("Expected excption does not contain a message. Stack trace: " + getStrackTrace(e));
     } else {
       if (!e.getMessage().contains(expectedMessagePart)) {
         fail(
             "Expected excption message does not contain a expected message part "
                 + expectedMessagePart
                 + ".  Stack trace: "
                 + getStrackTrace(e));
       }
     }
   }
   if (expectedCauseClass != null) {
     Throwable cause = e.getCause();
     assertNotNull("Expected cause exception" + expectedCauseClass.getName() + " missing", cause);
     if (expectedCauseClass != cause.getClass()) {
       fail(
           "Cause exception "
               + expectedCauseClass.getName()
               + " expected, but was "
               + cause.getClass().getName()
               + ": "
               + getStrackTrace(e));
     }
   }
 }
  @Test
  public void testUnmarshal() throws Exception {
    final String xml = "<Person><firstName>FOO</firstName><lastName>BAR</lastName></Person>";
    PersonType expected = new PersonType();
    expected.setFirstName("FOO");
    expected.setLastName("BAR");
    MockEndpoint resultEndpoint = resolveMandatoryEndpoint("mock:result", MockEndpoint.class);
    resultEndpoint.expectedBodiesReceived(expected);
    resultEndpoint.expectedHeaderReceived("foo", "bar");
    template.sendBodyAndHeader("direct:getJAXBElementValue", xml, "foo", "bar");

    resultEndpoint.assertIsSatisfied();
    resultEndpoint.reset();
    resultEndpoint.expectedMessageCount(1);
    template.sendBody("direct:getJAXBElement", xml);
    resultEndpoint.assertIsSatisfied();
    assertTrue(
        "We should get the JAXBElement here",
        resultEndpoint.getExchanges().get(0).getIn().getBody() instanceof JAXBElement);
  }
  @Test
  public void testPostStatusUpdateRequestResponse() throws Exception {
    Date now = new Date();
    String tweet = "UserProducerInOnlyTest: This is a tweet posted on " + now.toString();
    LOG.info("Tweet: " + tweet);
    ProducerTemplate producerTemplate = context.createProducerTemplate();
    // send tweet to the twitter endpoint
    producerTemplate.sendBodyAndHeader("direct:tweets", tweet, "customHeader", 12312);

    resultEndpoint.expectedMessageCount(1);
    resultEndpoint.expectedBodyReceived().body(String.class);
    // Message headers should be preserved
    resultEndpoint.expectedHeaderReceived("customHeader", 12312);
    resultEndpoint.assertIsSatisfied();

    List<Exchange> tweets = resultEndpoint.getExchanges();
    assertNotNull(tweets);
    assertThat(tweets.size(), is(1));
    String receivedTweet = tweets.get(0).getIn().getBody(String.class);
    assertThat(receivedTweet, is(tweet));
  }
Example #28
0
  @Test
  public void testOffline() throws InterruptedException {
    resultEndpoint.whenAnyExchangeReceived(
        new Processor() {
          @Override
          public void process(Exchange exchange) throws Exception {
            // Treat the endpoint as offline
            throw new Exception("OFFLINE");
          }
        });

    // Wait for 5 seconds while Camel route is exercised
    Thread.sleep(5000);
    // Ensure offline symptoms are reported
    final List<Exchange> exchanges = resultEndpoint.getExchanges();
    Assert.assertTrue(!exchanges.isEmpty());
    Assert.assertEquals(1, alerts);
    Assert.assertEquals(exchanges.size(), builder.getPingProcessor().getFailed());
    Assert.assertEquals(0, builder.getPingProcessor().getSucceeded());
    Assert.assertEquals(exchanges.size(), builder.getPingProcessor().getTotal());
  }
  @Test
  public void testFtpSimpleConsumeAbsolute() throws Exception {
    if (!canTest()) {
      return;
    }

    String expected = "Hello World";

    // create file using regular file

    // FTP Server does not support absolute path, so lets simulate it
    String path = FTP_ROOT_DIR + "/tmp/mytemp";
    template.sendBodyAndHeader("file:" + path, expected, Exchange.FILE_NAME, "hello.txt");

    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedMessageCount(1);
    mock.expectedHeaderReceived(Exchange.FILE_NAME, "hello.txt");

    context.startRoute("foo");

    assertMockEndpointsSatisfied();
    GenericFile<?> remoteFile = (GenericFile<?>) mock.getExchanges().get(0).getIn().getBody();
    assertTrue(remoteFile.getBody() instanceof InputStream);
  }
  @Test
  public void testMarshalPrettyPrint() throws Exception {
    PersonType person = new PersonType();
    person.setFirstName("Willem");
    person.setLastName("Jiang");
    resultEndpoint.expectedMessageCount(1);

    template.sendBody("direct:prettyPrint", person);

    resultEndpoint.assertIsSatisfied();

    Exchange exchange = resultEndpoint.getExchanges().get(0);

    String result = exchange.getIn().getBody(String.class);
    assertNotNull("The result should not be null", result);
    int indexPerson = result.indexOf("<Person>");
    int indexFirstName = result.indexOf("<firstName>");

    assertTrue("we should find the <Person>", indexPerson > 0);
    assertTrue("we should find the <firstName>", indexFirstName > 0);
    assertTrue(
        "There should some sapce between <Person> and <firstName>",
        indexFirstName - indexPerson > 8);
  }