Added unit tests.
Project: http://git-wip-us.apache.org/repos/asf/camel/repo Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/225d11d9 Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/225d11d9 Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/225d11d9 Branch: refs/heads/master Commit: 225d11d9df8c4b4aa7af5068c60c007b27b853ee Parents: 98560c8 Author: Lauri Kimmel <lauri.kim...@gmx.com> Authored: Tue May 13 22:47:26 2014 +1000 Committer: Lauri Kimmel <lauri.kim...@gmx.com> Committed: Tue May 13 22:47:26 2014 +1000 ---------------------------------------------------------------------- pom.xml | 41 +++- .../apache/camel/metrics/MetricsComponent.java | 31 ++- .../metrics/AbstractMetricsEndpointTest.java | 81 +++++++ .../metrics/MetricComponentSpringTest.java | 77 +++++++ .../metrics/MetricsComponentRouteTest.java | 42 ++++ .../camel/metrics/MetricsComponentTest.java | 228 ++++++++++++++++--- .../apache/camel/metrics/MetricsTypeTest.java | 19 ++ .../metrics/counter/CounterEndpointTest.java | 88 +++++++ .../metrics/counter/CounterProducerTest.java | 112 +++++++++ .../camel/metrics/meter/MeterEndpointTest.java | 75 ++++++ .../camel/metrics/meter/MeterProducerTest.java | 81 +++++++ 11 files changed, 821 insertions(+), 54 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/pom.xml ---------------------------------------------------------------------- diff --git a/pom.xml b/pom.xml index 2407292..0f65ab5 100644 --- a/pom.xml +++ b/pom.xml @@ -54,13 +54,50 @@ <version>2.13.0</version> <scope>test</scope> </dependency> + <dependency> + <groupId>org.apache.camel</groupId> + <artifactId>camel-spring</artifactId> + <version>2.13.0</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.apache.camel</groupId> + <artifactId>camel-spring-javaconfig</artifactId> + <version>2.13.0</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.apache.camel</groupId> + <artifactId>camel-test-spring</artifactId> + <version>2.13.0</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.mockito</groupId> + <artifactId>mockito-core</artifactId> + <version>1.9.5</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + <version>4.11</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.hamcrest</groupId> + <artifactId>hamcrest-all</artifactId> + <version>1.3</version> + <scope>test</scope> + </dependency> + </dependencies> <build> <defaultGoal>install</defaultGoal> <plugins> - + <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> @@ -70,7 +107,7 @@ <target>1.6</target> </configuration> </plugin> - + <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-resources-plugin</artifactId> http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/main/java/org/apache/camel/metrics/MetricsComponent.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/camel/metrics/MetricsComponent.java b/src/main/java/org/apache/camel/metrics/MetricsComponent.java index 14e93cb..b6af8af 100644 --- a/src/main/java/org/apache/camel/metrics/MetricsComponent.java +++ b/src/main/java/org/apache/camel/metrics/MetricsComponent.java @@ -9,6 +9,7 @@ import org.apache.camel.impl.DefaultComponent; import org.apache.camel.metrics.counter.CounterEndpoint; import org.apache.camel.metrics.meter.MeterEndpoint; import org.apache.camel.spi.Registry; +import org.apache.camel.util.ObjectHelper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -20,7 +21,7 @@ import com.codahale.metrics.Slf4jReporter; */ public class MetricsComponent extends DefaultComponent { - public static final String NAME_METRIC_REGISTRY = "metricRegistry"; + public static final String METRIC_REGISTRY_NAME = "metricRegistry"; public static final MetricsType DEFAULT_METRICS_TYPE = MetricsType.METER; public static final long DEFAULT_REPORTING_INTERVAL_SECONDS = 60L; @@ -30,8 +31,10 @@ public class MetricsComponent extends DefaultComponent { @Override protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception { - Registry camelRegistry = getCamelContext().getRegistry(); - getOrCreateMetricRegistry(camelRegistry, NAME_METRIC_REGISTRY); + if (metricRegistry == null) { + Registry camelRegistry = getCamelContext().getRegistry(); + metricRegistry = getOrCreateMetricRegistry(camelRegistry, METRIC_REGISTRY_NAME); + } String metricsName = getMetricsName(remaining); MetricsType metricsType = getMetricsType(remaining); LOG.info("Metrics type: {}; name: {}", metricsType, metricsName); @@ -41,8 +44,8 @@ public class MetricsComponent extends DefaultComponent { } String getMetricsName(String remaining) { - int index = remaining.indexOf(":"); - return index < 0 ? remaining : remaining.substring(index + 1); + String name = ObjectHelper.after(remaining, ":"); + return name == null ? remaining : name; } Endpoint createNewEndpoint(MetricRegistry registry, MetricsType type, String metricsName) { @@ -61,14 +64,12 @@ public class MetricsComponent extends DefaultComponent { } MetricsType getMetricsType(String remaining) { - int index = remaining.indexOf(":"); - String name = null; + String name = ObjectHelper.before(remaining, ":"); MetricsType type; - if (index < 0) { + if (name == null) { type = DEFAULT_METRICS_TYPE; } else { - name = remaining.substring(0, index); type = MetricsType.getByName(name); } if (type == null) { @@ -78,16 +79,14 @@ public class MetricsComponent extends DefaultComponent { } MetricRegistry getOrCreateMetricRegistry(Registry camelRegistry, String registryName) { - if (metricRegistry == null) { - LOG.debug("Looking up MetricRegistry from Camel Registry for name \"{}\"", registryName); - metricRegistry = getMetricRegistryFromCamelRegistry(camelRegistry, registryName); - } - if (metricRegistry == null) { + LOG.debug("Looking up MetricRegistry from Camel Registry for name \"{}\"", registryName); + MetricRegistry result = getMetricRegistryFromCamelRegistry(camelRegistry, registryName); + if (result == null) { LOG.debug("MetricRegistry not found from Camel Registry for name \"{}\"", registryName); LOG.info("Creating new default MetricRegistry"); - metricRegistry = createMetricRegistry(); + result = createMetricRegistry(); } - return metricRegistry; + return result; } MetricRegistry getMetricRegistryFromCamelRegistry(Registry camelRegistry, String registryName) { http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/AbstractMetricsEndpointTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/AbstractMetricsEndpointTest.java b/src/test/java/org/apache/camel/metrics/AbstractMetricsEndpointTest.java new file mode 100644 index 0000000..0b24cf8 --- /dev/null +++ b/src/test/java/org/apache/camel/metrics/AbstractMetricsEndpointTest.java @@ -0,0 +1,81 @@ +package org.apache.camel.metrics; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.apache.camel.Processor; +import org.apache.camel.Producer; +import org.apache.camel.RuntimeCamelException; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +import com.codahale.metrics.MetricRegistry; + +@RunWith(MockitoJUnitRunner.class) +public class AbstractMetricsEndpointTest { + + private static final String METRICS_NAME = "metrics.name"; + + @Mock + private MetricRegistry registry; + + @Mock + private Processor processor; + + private AbstractMetricsEndpoint endpoint; + + private InOrder inOrder; + + @Before + public void setUp() throws Exception { + endpoint = new AbstractMetricsEndpoint(registry, METRICS_NAME) { + @Override + public Producer createProducer() throws Exception { + return null; + } + + @Override + protected String createEndpointUri() { + return "not real endpoint"; + } + }; + inOrder = Mockito.inOrder(registry, processor); + } + + @After + public void tearDown() throws Exception { + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testAbstractMetricsEndpoint() throws Exception { + assertThat(endpoint.getMetricsName(), is(METRICS_NAME)); + assertThat(endpoint.getRegistry(), is(registry)); + } + + @Test(expected = RuntimeCamelException.class) + public void testCreateConsumer() throws Exception { + endpoint.createConsumer(processor); + } + + @Test + public void testIsSingleton() throws Exception { + assertThat(endpoint.isSingleton(), is(false)); + } + + @Test + public void testGetRegistry() throws Exception { + assertThat(endpoint.getRegistry(), is(registry)); + } + + @Test + public void testGetMetricsName() throws Exception { + assertThat(endpoint.getMetricsName(), is(METRICS_NAME)); + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/MetricComponentSpringTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/MetricComponentSpringTest.java b/src/test/java/org/apache/camel/metrics/MetricComponentSpringTest.java new file mode 100644 index 0000000..2dd9391 --- /dev/null +++ b/src/test/java/org/apache/camel/metrics/MetricComponentSpringTest.java @@ -0,0 +1,77 @@ +package org.apache.camel.metrics; + +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.when; + +import org.apache.camel.EndpointInject; +import org.apache.camel.Produce; +import org.apache.camel.ProducerTemplate; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.spring.javaconfig.SingleRouteCamelConfiguration; +import org.apache.camel.test.spring.CamelSpringDelegatingTestContextLoader; +import org.apache.camel.test.spring.CamelSpringJUnit4ClassRunner; +import org.apache.camel.test.spring.MockEndpoints; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InOrder; +import org.mockito.Mockito; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.test.context.ContextConfiguration; + +import com.codahale.metrics.Counter; +import com.codahale.metrics.MetricRegistry; + +@RunWith(CamelSpringJUnit4ClassRunner.class) +@ContextConfiguration( + classes = { MetricComponentSpringTest.TestConfig.class }, + loader = CamelSpringDelegatingTestContextLoader.class) +@MockEndpoints +public class MetricComponentSpringTest { + + @EndpointInject(uri = "mock:out") + private MockEndpoint endpoint; + + @Produce(uri = "direct:in") + private ProducerTemplate producer; + + @Configuration + public static class TestConfig extends SingleRouteCamelConfiguration { + + @Bean + @Override + public RouteBuilder route() { + return new RouteBuilder() { + + @Override + public void configure() throws Exception { + from("direct:in") + .to("metrics:counter:A?increment=512") + .to("mock:out"); + } + }; + } + + @Bean(name = MetricsComponent.METRIC_REGISTRY_NAME) + public MetricRegistry getMetricRegistry() { + return Mockito.mock(MetricRegistry.class); + } + } + + @Test + public void testMetricsRegistryFromCamelRegistry() throws Exception { + // TODO - 12.05.2014, Lauri - is there any better way to set this up? + MetricRegistry mockRegistry = endpoint.getCamelContext().getRegistry().lookupByNameAndType(MetricsComponent.METRIC_REGISTRY_NAME, MetricRegistry.class); + Counter mockCounter = Mockito.mock(Counter.class); + InOrder inOrder = Mockito.inOrder(mockRegistry, mockCounter); + when(mockRegistry.counter("A")).thenReturn(mockCounter); + + endpoint.expectedMessageCount(1); + producer.sendBody(new Object()); + endpoint.assertIsSatisfied(); + inOrder.verify(mockRegistry, times(1)).counter("A"); + inOrder.verify(mockCounter, times(1)).inc(512); + inOrder.verifyNoMoreInteractions(); + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/MetricsComponentRouteTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/MetricsComponentRouteTest.java b/src/test/java/org/apache/camel/metrics/MetricsComponentRouteTest.java new file mode 100644 index 0000000..b005b93 --- /dev/null +++ b/src/test/java/org/apache/camel/metrics/MetricsComponentRouteTest.java @@ -0,0 +1,42 @@ +package org.apache.camel.metrics; + +import org.apache.camel.Produce; +import org.apache.camel.ProducerTemplate; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.test.junit4.CamelTestSupport; +import org.junit.Test; + +public class MetricsComponentRouteTest extends CamelTestSupport { + + @Produce(uri = "direct:start") + protected ProducerTemplate template; + + @Test + public void testMetrics() throws Exception { + MockEndpoint mock = getMockEndpoint("mock:result"); + mock.expectedMinimumMessageCount(1); + template.sendBody(new Object()); + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start") + // .to("metrics") + // .to("metrics:") + .to("metrics:A") + .to("metrics:counter://B") + .to("metrics:counter:C?increment=19291") + .to("metrics:counter:C?decrement=19292") + .to("metrics:counter:C") + .to("metrics:meter:D") + .to("metrics:meter:D?mark=90001") + .to("mock:result"); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/MetricsComponentTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/MetricsComponentTest.java b/src/test/java/org/apache/camel/metrics/MetricsComponentTest.java index 8eb6b42..f8dd013 100644 --- a/src/test/java/org/apache/camel/metrics/MetricsComponentTest.java +++ b/src/test/java/org/apache/camel/metrics/MetricsComponentTest.java @@ -1,42 +1,198 @@ package org.apache.camel.metrics; -import org.apache.camel.Produce; -import org.apache.camel.ProducerTemplate; -import org.apache.camel.builder.RouteBuilder; -import org.apache.camel.component.mock.MockEndpoint; -import org.apache.camel.test.junit4.CamelTestSupport; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.Matchers.not; +import static org.hamcrest.Matchers.notNullValue; +import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.when; + +import java.util.EnumSet; +import java.util.HashMap; +import java.util.Map; + +import org.apache.camel.CamelContext; +import org.apache.camel.Endpoint; +import org.apache.camel.RuntimeCamelException; +import org.apache.camel.metrics.counter.CounterEndpoint; +import org.apache.camel.metrics.meter.MeterEndpoint; +import org.apache.camel.spi.Registry; +import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +import com.codahale.metrics.MetricRegistry; + +@RunWith(MockitoJUnitRunner.class) +public class MetricsComponentTest { + + @Mock + private CamelContext camelContext; + + @Mock + private Registry camelRegistry; + + @Mock + private MetricRegistry metricRegistry; + + private InOrder inOrder; + + private MetricsComponent component; + + @Before + public void setUp() throws Exception { + component = new MetricsComponent(); + inOrder = Mockito.inOrder(camelContext, camelRegistry, metricRegistry); + + } + + @Test + public void testCreateEndpoint() throws Exception { + component.setCamelContext(camelContext); + when(camelContext.getRegistry()).thenReturn(camelRegistry); + when(camelRegistry.lookupByNameAndType(MetricsComponent.METRIC_REGISTRY_NAME, MetricRegistry.class)).thenReturn(metricRegistry); + Map<String, Object> params = new HashMap<String, Object>(); + Long value = System.currentTimeMillis(); + params.put("mark", value); + Endpoint result = component.createEndpoint("metrics:meter:long.meter", "meter:long.meter", params); + assertThat(result, is(notNullValue())); + assertThat(result, is(instanceOf(MeterEndpoint.class))); + MeterEndpoint me = (MeterEndpoint) result; + assertThat(me.getMark(), is(value)); + assertThat(me.getMetricsName(), is("long.meter")); + assertThat(me.getRegistry(), is(metricRegistry)); + inOrder.verify(camelContext, times(1)).getRegistry(); + inOrder.verify(camelRegistry, times(1)).lookupByNameAndType(MetricsComponent.METRIC_REGISTRY_NAME, MetricRegistry.class); + inOrder.verify(camelContext, times(1)).getTypeConverter(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testCreateEndpoints() throws Exception { + component.setCamelContext(camelContext); + when(camelContext.getRegistry()).thenReturn(camelRegistry); + when(camelRegistry.lookupByNameAndType(MetricsComponent.METRIC_REGISTRY_NAME, MetricRegistry.class)).thenReturn(metricRegistry); + Map<String, Object> params = new HashMap<String, Object>(); + Long value = System.currentTimeMillis(); + params.put("mark", value); + Endpoint result = component.createEndpoint("metrics:meter:long.meter", "meter:long.meter", params); + assertThat(result, is(notNullValue())); + assertThat(result, is(instanceOf(MeterEndpoint.class))); + MeterEndpoint me = (MeterEndpoint) result; + assertThat(me.getMark(), is(value)); + assertThat(me.getMetricsName(), is("long.meter")); + assertThat(me.getRegistry(), is(metricRegistry)); + + params = new HashMap<String, Object>(); + params.put("increment", value + 1); + params.put("decrement", value - 1); + + result = component.createEndpoint("metrics:counter:long.counter", "counter:long.counter", params); + assertThat(result, is(notNullValue())); + assertThat(result, is(instanceOf(CounterEndpoint.class))); + CounterEndpoint ce = (CounterEndpoint) result; + assertThat(ce.getIncrement(), is(value + 1)); + assertThat(ce.getDecrement(), is(value - 1)); + assertThat(ce.getMetricsName(), is("long.counter")); + assertThat(ce.getRegistry(), is(metricRegistry)); + + inOrder.verify(camelContext, times(1)).getRegistry(); + inOrder.verify(camelRegistry, times(1)).lookupByNameAndType(MetricsComponent.METRIC_REGISTRY_NAME, MetricRegistry.class); + inOrder.verify(camelContext, times(2)).getTypeConverter(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testGetMetricsName() throws Exception { + assertThat(component.getMetricsName("meter:metric-a"), is("metric-a")); + assertThat(component.getMetricsName("meter:metric-a:sub-b"), is("metric-a:sub-b")); + assertThat(component.getMetricsName("metric-a"), is("metric-a")); + assertThat(component.getMetricsName("//metric-a"), is("//metric-a")); + assertThat(component.getMetricsName("meter://metric-a"), is("//metric-a")); + } + + @Test + public void testCreateNewEndpointForCounter() throws Exception { + Endpoint endpoint = component.createNewEndpoint(metricRegistry, MetricsType.COUNTER, "a name"); + assertThat(endpoint, is(notNullValue())); + assertThat(endpoint, is(instanceOf(CounterEndpoint.class))); + } -public class MetricsComponentTest extends CamelTestSupport { - - @Produce(uri = "direct:start") - protected ProducerTemplate template; - - @Test - public void testMetrics() throws Exception { - MockEndpoint mock = getMockEndpoint("mock:result"); - mock.expectedMinimumMessageCount(1); - template.sendBody(new Object()); - assertMockEndpointsSatisfied(); - } - - @Override - protected RouteBuilder createRouteBuilder() throws Exception { - return new RouteBuilder() { - @Override - public void configure() { - from("direct:start") - // .to("metrics") - // .to("metrics:") - .to("metrics:A") - .to("metrics:counter://B") - .to("metrics:counter:C?increment=19291") - .to("metrics:counter:C?decrement=19292") - .to("metrics:counter:C") - .to("metrics:meter:D") - .to("metrics:meter:D?mark=90001") - .to("mock:result"); - } - }; + @Test + public void testCreateNewEndpointForMeter() throws Exception { + Endpoint endpoint = component.createNewEndpoint(metricRegistry, MetricsType.METER, "a name"); + assertThat(endpoint, is(notNullValue())); + assertThat(endpoint, is(instanceOf(MeterEndpoint.class))); + } + + @Test(expected = RuntimeCamelException.class) + public void testCreateNewEndpointForGauge() throws Exception { + component.createNewEndpoint(metricRegistry, MetricsType.GAUGE, "a name"); + } + + @Test(expected = RuntimeCamelException.class) + public void testCreateNewEndpointForHistogram() throws Exception { + component.createNewEndpoint(metricRegistry, MetricsType.HISTOGRAM, "a name"); + } + + @Test(expected = RuntimeCamelException.class) + public void testCreateNewEndpointForTimer() throws Exception { + component.createNewEndpoint(metricRegistry, MetricsType.TIMER, "a name"); + } + + @Test + public void testGetMetricsType() throws Exception { + for (MetricsType type : EnumSet.allOf(MetricsType.class)) { + assertThat(component.getMetricsType(type.toString() + ":metrics-name"), is(type)); + } + } + + @Test + public void testGetMetricsTypeNotSet() throws Exception { + assertThat(component.getMetricsType("no-metrics-type"), is(MetricsComponent.DEFAULT_METRICS_TYPE)); + } + + @Test(expected = RuntimeCamelException.class) + public void testGetMetricsTypeNotFound() throws Exception { + component.getMetricsType("unknown-metrics:metrics-name"); + } + + @Test + public void testGetOrCreateMetricRegistryFoundInCamelRegistry() throws Exception { + when(camelRegistry.lookupByNameAndType("name", MetricRegistry.class)).thenReturn(metricRegistry); + MetricRegistry result = component.getOrCreateMetricRegistry(camelRegistry, "name"); + assertThat(result, is(metricRegistry)); + inOrder.verify(camelRegistry, times(1)).lookupByNameAndType("name", MetricRegistry.class); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testGetOrCreateMetricRegistryNotFoundInCamelRegistry() throws Exception { + when(camelRegistry.lookupByNameAndType("name", MetricRegistry.class)).thenReturn(null); + MetricRegistry result = component.getOrCreateMetricRegistry(camelRegistry, "name"); + assertThat(result, is(notNullValue())); + assertThat(result, is(not(metricRegistry))); + inOrder.verify(camelRegistry, times(1)).lookupByNameAndType("name", MetricRegistry.class); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testGetMetricRegistryFromCamelRegistry() throws Exception { + when(camelRegistry.lookupByNameAndType("name", MetricRegistry.class)).thenReturn(metricRegistry); + MetricRegistry result = component.getMetricRegistryFromCamelRegistry(camelRegistry, "name"); + assertThat(result, is(metricRegistry)); + inOrder.verify(camelRegistry, times(1)).lookupByNameAndType("name", MetricRegistry.class); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testCreateMetricRegistry() throws Exception { + MetricRegistry registry = component.createMetricRegistry(); + assertThat(registry, is(notNullValue())); } } http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/MetricsTypeTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/MetricsTypeTest.java b/src/test/java/org/apache/camel/metrics/MetricsTypeTest.java new file mode 100644 index 0000000..2d0d28d --- /dev/null +++ b/src/test/java/org/apache/camel/metrics/MetricsTypeTest.java @@ -0,0 +1,19 @@ +package org.apache.camel.metrics; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; + +import java.util.EnumSet; + +import org.junit.Test; + +public class MetricsTypeTest { + + @Test + public void testGetByName() throws Exception { + for (MetricsType type : EnumSet.allOf(MetricsType.class)) { + MetricsType t = MetricsType.getByName(type.toString()); + assertThat(t, is(type)); + } + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/counter/CounterEndpointTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/counter/CounterEndpointTest.java b/src/test/java/org/apache/camel/metrics/counter/CounterEndpointTest.java new file mode 100644 index 0000000..8f713a2 --- /dev/null +++ b/src/test/java/org/apache/camel/metrics/counter/CounterEndpointTest.java @@ -0,0 +1,88 @@ +package org.apache.camel.metrics.counter; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.Matchers.notNullValue; +import static org.hamcrest.Matchers.nullValue; + +import org.apache.camel.Producer; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +import com.codahale.metrics.MetricRegistry; + +@RunWith(MockitoJUnitRunner.class) +public class CounterEndpointTest { + + private static final String METRICS_NAME = "metrics.name"; + private static final Long VALUE = System.currentTimeMillis(); + + @Mock + private MetricRegistry registry; + + private CounterEndpoint endpoint; + + private InOrder inOrder; + + @Before + public void setUp() throws Exception { + endpoint = new CounterEndpoint(registry, METRICS_NAME); + inOrder = Mockito.inOrder(registry); + } + + @After + public void tearDown() { + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testCounterEndpoint() throws Exception { + assertThat(endpoint.getRegistry(), is(registry)); + assertThat(endpoint.getMetricsName(), is(METRICS_NAME)); + assertThat(endpoint.getIncrement(), is(nullValue())); + assertThat(endpoint.getDecrement(), is(nullValue())); + } + + @Test + public void testCreateProducer() throws Exception { + Producer producer = endpoint.createProducer(); + assertThat(producer, is(notNullValue())); + assertThat(producer, is(instanceOf(CounterProducer.class))); + } + + @Test + public void testGetIncrement() throws Exception { + assertThat(endpoint.getIncrement(), is(nullValue())); + } + + @Test + public void testSetIncrement() throws Exception { + assertThat(endpoint.getIncrement(), is(nullValue())); + endpoint.setIncrement(VALUE); + assertThat(endpoint.getIncrement(), is(VALUE)); + } + + @Test + public void testGetDecrement() throws Exception { + assertThat(endpoint.getDecrement(), is(nullValue())); + } + + @Test + public void testSetDecrement() throws Exception { + assertThat(endpoint.getDecrement(), is(nullValue())); + endpoint.setDecrement(VALUE); + assertThat(endpoint.getDecrement(), is(VALUE)); + } + + @Test + public void testCreateEndpointUri() throws Exception { + assertThat(endpoint.createEndpointUri(), is(CounterEndpoint.ENDPOINT_URI)); + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/counter/CounterProducerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/counter/CounterProducerTest.java b/src/test/java/org/apache/camel/metrics/counter/CounterProducerTest.java new file mode 100644 index 0000000..3b1b89b --- /dev/null +++ b/src/test/java/org/apache/camel/metrics/counter/CounterProducerTest.java @@ -0,0 +1,112 @@ +package org.apache.camel.metrics.counter; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.when; + +import org.apache.camel.Exchange; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +import com.codahale.metrics.Counter; +import com.codahale.metrics.MetricRegistry; + +@RunWith(MockitoJUnitRunner.class) +public class CounterProducerTest { + + private static final String ENDPOINT_NAME = "endpoint.name"; + private static final Long INCREMENT = 100000L; + private static final Long DECREMENT = 91929199L; + + @Mock + private CounterEndpoint endpoint; + + @Mock + private Exchange exchange; + + @Mock + private MetricRegistry registry; + + @Mock + private Counter counter; + + private CounterProducer producer; + + private InOrder inOrder; + + @Before + public void setUp() throws Exception { + producer = new CounterProducer(endpoint); + inOrder = Mockito.inOrder(endpoint, exchange, registry, counter); + when(endpoint.getMetricsName()).thenReturn(ENDPOINT_NAME); + when(endpoint.getRegistry()).thenReturn(registry); + when(registry.counter(ENDPOINT_NAME)).thenReturn(counter); + } + + @Test + public void testCounterProducer() throws Exception { + assertThat(producer.getEndpoint().equals(endpoint), is(true)); + } + + @Test + public void testProcessWithIncrementOnly() throws Exception { + when(endpoint.getIncrement()).thenReturn(INCREMENT); + when(endpoint.getDecrement()).thenReturn(null); + producer.process(exchange); + inOrder.verify(endpoint, times(1)).getMetricsName(); + inOrder.verify(endpoint, times(1)).getRegistry(); + inOrder.verify(registry, times(1)).counter(ENDPOINT_NAME); + inOrder.verify(endpoint, times(1)).getIncrement(); + inOrder.verify(endpoint, times(1)).getDecrement(); + inOrder.verify(counter, times(1)).inc(INCREMENT); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testProcessWithDecrementOnly() throws Exception { + when(endpoint.getIncrement()).thenReturn(null); + when(endpoint.getDecrement()).thenReturn(DECREMENT); + producer.process(exchange); + inOrder.verify(endpoint, times(1)).getMetricsName(); + inOrder.verify(endpoint, times(1)).getRegistry(); + inOrder.verify(registry, times(1)).counter(ENDPOINT_NAME); + inOrder.verify(endpoint, times(1)).getIncrement(); + inOrder.verify(endpoint, times(1)).getDecrement(); + inOrder.verify(counter, times(1)).dec(DECREMENT); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testProcessWithIncrementAndDecrement() throws Exception { + when(endpoint.getIncrement()).thenReturn(INCREMENT); + when(endpoint.getDecrement()).thenReturn(DECREMENT); + producer.process(exchange); + inOrder.verify(endpoint, times(1)).getMetricsName(); + inOrder.verify(endpoint, times(1)).getRegistry(); + inOrder.verify(registry, times(1)).counter(ENDPOINT_NAME); + inOrder.verify(endpoint, times(1)).getIncrement(); + inOrder.verify(endpoint, times(1)).getDecrement(); + inOrder.verify(counter, times(1)).inc(INCREMENT); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testProcessWithOutIncrementAndDecrement() throws Exception { + when(endpoint.getIncrement()).thenReturn(null); + when(endpoint.getDecrement()).thenReturn(null); + producer.process(exchange); + inOrder.verify(endpoint, times(1)).getMetricsName(); + inOrder.verify(endpoint, times(1)).getRegistry(); + inOrder.verify(registry, times(1)).counter(ENDPOINT_NAME); + inOrder.verify(endpoint, times(1)).getIncrement(); + inOrder.verify(endpoint, times(1)).getDecrement(); + inOrder.verify(counter, times(1)).inc(); + inOrder.verifyNoMoreInteractions(); + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/meter/MeterEndpointTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/meter/MeterEndpointTest.java b/src/test/java/org/apache/camel/metrics/meter/MeterEndpointTest.java new file mode 100644 index 0000000..3779da9 --- /dev/null +++ b/src/test/java/org/apache/camel/metrics/meter/MeterEndpointTest.java @@ -0,0 +1,75 @@ +package org.apache.camel.metrics.meter; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.Matchers.notNullValue; +import static org.hamcrest.Matchers.nullValue; + +import org.apache.camel.Producer; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +import com.codahale.metrics.MetricRegistry; + +@RunWith(MockitoJUnitRunner.class) +public class MeterEndpointTest { + + private static final String METRICS_NAME = "metrics.name"; + private static final Long VALUE = System.currentTimeMillis(); + + @Mock + private MetricRegistry registry; + + private MeterEndpoint endpoint; + + private InOrder inOrder; + + @Before + public void setUp() throws Exception { + endpoint = new MeterEndpoint(registry, METRICS_NAME); + inOrder = Mockito.inOrder(registry); + } + + @After + public void tearDown() throws Exception { + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMeterEndpoint() throws Exception { + assertThat(endpoint, is(notNullValue())); + assertThat(endpoint.getRegistry(), is(registry)); + assertThat(endpoint.getMetricsName(), is(METRICS_NAME)); + } + + @Test + public void testCreateProducer() throws Exception { + Producer producer = endpoint.createProducer(); + assertThat(producer, is(notNullValue())); + assertThat(producer, is(instanceOf(MeterProducer.class))); + } + + @Test + public void testGetMark() throws Exception { + assertThat(endpoint.getMark(), is(nullValue())); + } + + @Test + public void testSetMark() throws Exception { + assertThat(endpoint.getMark(), is(nullValue())); + endpoint.setMark(VALUE); + assertThat(endpoint.getMark(), is(VALUE)); + } + + @Test + public void testCreateEndpointUri() throws Exception { + assertThat(endpoint.createEndpointUri(), is(MeterEndpoint.ENDPOINT_URI)); + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/225d11d9/src/test/java/org/apache/camel/metrics/meter/MeterProducerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/camel/metrics/meter/MeterProducerTest.java b/src/test/java/org/apache/camel/metrics/meter/MeterProducerTest.java new file mode 100644 index 0000000..26c853a --- /dev/null +++ b/src/test/java/org/apache/camel/metrics/meter/MeterProducerTest.java @@ -0,0 +1,81 @@ +package org.apache.camel.metrics.meter; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.notNullValue; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.when; + +import org.apache.camel.Exchange; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +import com.codahale.metrics.Meter; +import com.codahale.metrics.MetricRegistry; + +@RunWith(MockitoJUnitRunner.class) +public class MeterProducerTest { + + private static final String METRICS_NAME = "metrics.name"; + private static final Long MARK = 9919120L; + + @Mock + private MeterEndpoint endpoint; + + @Mock + private MetricRegistry registry; + + @Mock + private Meter meter; + + @Mock + private Exchange exchange; + + private MeterProducer producer; + + private InOrder inOrder; + + @Before + public void setUp() throws Exception { + producer = new MeterProducer(endpoint); + inOrder = Mockito.inOrder(endpoint, registry, meter, exchange); + when(endpoint.getRegistry()).thenReturn(registry); + when(endpoint.getMetricsName()).thenReturn(METRICS_NAME); + when(registry.meter(METRICS_NAME)).thenReturn(meter); + } + + @Test + public void testMeterProducer() throws Exception { + assertThat(producer, is(notNullValue())); + assertThat(producer.getEndpoint().equals(endpoint), is(true)); + } + + @Test + public void testProcessMarkSet() throws Exception { + when(endpoint.getMark()).thenReturn(MARK); + producer.process(exchange); + inOrder.verify(endpoint, times(1)).getMetricsName(); + inOrder.verify(endpoint, times(1)).getRegistry(); + inOrder.verify(registry, times(1)).meter(METRICS_NAME); + inOrder.verify(endpoint, times(1)).getMark(); + inOrder.verify(meter, times(1)).mark(MARK); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testProcessMarkNotSet() throws Exception { + when(endpoint.getMark()).thenReturn(null); + producer.process(exchange); + inOrder.verify(endpoint, times(1)).getMetricsName(); + inOrder.verify(endpoint, times(1)).getRegistry(); + inOrder.verify(registry, times(1)).meter(METRICS_NAME); + inOrder.verify(endpoint, times(1)).getMark(); + inOrder.verify(meter, times(1)).mark(); + inOrder.verifyNoMoreInteractions(); + } +}
