public void createBatchSubscription(Topic topic, String endpoint, BatchSubscriptionPolicy policy) { Subscription subscription = subscription(topic, "batchSubscription") .withEndpoint(endpoint) .withContentType(ContentType.JSON) .withSubscriptionPolicy(policy) .build(); createSubscription(topic, subscription); }
public void createBatchSubscription(Topic topic, String endpoint, BatchSubscriptionPolicy policy) { Subscription subscription = subscription(topic, "batchSubscription") .withEndpoint(endpoint) .withContentType(ContentType.JSON) .withSubscriptionPolicy(policy) .build(); createSubscription(topic, subscription); }
@Test public void shouldDispatchCorrectTracker() { assertThat(trackers.get(subscription("group.topic", "sub").withTrackingMode(TrackingMode.TRACKING_OFF) .build())).isEqualTo(noOperationDeliveryTracker); assertThat(trackers.get(subscription("group.topic", "sub") .withTrackingMode(TrackingMode.TRACK_DISCARDED_ONLY).build())).isEqualTo(discardedSendingTracker); assertThat(trackers.get(subscription("group.topic", "sub").withTrackingMode(TrackingMode.TRACK_ALL) .build())).isEqualTo(messageDeliveryTracker); }
private Subscription subscriptionWithRequestTimeout(int timeout) { return subscriptionBuilderWithTestValues().withRequestTimeout(timeout).build(); }
private Subscription subscriptionWithEndpoint(String endpoint) { return subscriptionBuilderWithTestValues().withEndpoint(endpoint).build(); }
private Subscription anySubscription() { SubscriptionName name = SubscriptionName.fromString("com.test.topic$" + Math.abs(UUID.randomUUID().getMostSignificantBits())); Subscription subscription = subscription(name).build(); given(subscriptionRepository.getSubscriptionDetails(name)).willReturn(subscription); return subscription; }
@Before public void setup() { ConfigFactory config = mock(ConfigFactory.class); when(config.getDoubleProperty(Configs.CONSUMER_RATE_CONVERGENCE_FACTOR)).thenReturn(0.5); when(config.getIntProperty(Configs.CONSUMER_RATE_LIMITER_SLOW_MODE_DELAY)).thenReturn(1); when(config.getIntProperty(Configs.CONSUMER_RATE_LIMITER_HEARTBEAT_MODE_DELAY)).thenReturn(60); subscription = subscription("group.topic", "subscription").withSubscriptionPolicy( SubscriptionPolicy.Builder.subscriptionPolicy().withRate(200).build() ).build(); NegotiatedMaxRateProvider maxRateProvider = mock(NegotiatedMaxRateProvider.class); when(maxRateProvider.get()).thenReturn(100D); calculator = new OutputRateCalculator(config, maxRateProvider); }
@Test public void shouldGetProtocolNotSupportedExceptionWhenPassingUnknownUri() { // given Subscription subscription = subscription("group.topic", "subscription", "unknown://localhost:8080/test").build(); // when catchException(factory).create(subscription); // then assertThat(CatchException.<EndpointProtocolNotSupportedException>caughtException()) .isInstanceOf(EndpointProtocolNotSupportedException.class); }
@Test public void shouldAnonymizePassword() { // given Subscription subscription = subscription("group.topic", "subscription").withEndpoint("http://user:password@service/path").build(); // when & then assertThat(subscription.anonymize().getEndpoint()).isEqualTo(new EndpointAddress("http://user:*****@service/path")); }
@Test public void shouldCreateCustomProtocolMessageSender() { // given EndpointAddress endpoint = EndpointAddress.of("myProtocol://service"); Subscription subscription = subscription("group.topic", "subscription", endpoint).build(); factory.addSupportedProtocol("myProtocol", protocolMessageSenderProviderReturning(referenceMessageSender)); // when MessageSender sender = factory.create(subscription); // then assertThat(sender).isEqualTo(referenceMessageSender); }
@Test public void shouldDelaySendingMessageForHalfSecond() { // given Subscription subscription = subscriptionBuilderWithTestValues() .withSubscriptionPolicy(subscriptionPolicy().applyDefaults() .withSendingDelay(500) .build()) .build(); setUpMetrics(subscription); Message message = message(); when(messageSender.send(message)).thenReturn(success()); ConsumerMessageSender sender = consumerMessageSender(subscription); // when long sendingStartTime = System.currentTimeMillis(); sender.sendAsync(message); verify(successHandler, timeout(1000)).handleSuccess(eq(message), eq(subscription), any(MessageSendingResult.class)); // then long sendingTime = System.currentTimeMillis() - sendingStartTime; assertThat(sendingTime).isGreaterThan(500); }
public Subscription createSubscription(Topic topic, String subscriptionName, String endpoint, ContentType contentType, SubscriptionMode mode, Subscription.State state) { Subscription subscription = subscription(topic, subscriptionName) .withEndpoint(endpoint) .withContentType(contentType) .withSubscriptionPolicy(subscriptionPolicy().applyDefaults().build()) .withMode(mode) .withState(state) .build(); return createSubscription(topic, subscription); }
public Subscription createSubscription(Topic topic, String subscriptionName, String endpoint, ContentType contentType, SubscriptionMode mode, Subscription.State state) { Subscription subscription = subscription(topic, subscriptionName) .withEndpoint(endpoint) .withContentType(contentType) .withSubscriptionPolicy(subscriptionPolicy().applyDefaults().build()) .withMode(mode) .withState(state) .build(); return createSubscription(topic, subscription); }
@Test public void shouldPatchNestedObjects() { // given Subscription subscription = subscription("group.topic", "sub").build(); PatchData patch = patchData().set( "subscriptionPolicy", patchData().set("rate", 200).set("messageTtl", 8).build().getPatch() ).build(); // when SubscriptionPolicy result = Patch.apply(subscription, patch).getSerialSubscriptionPolicy(); // then assertThat(result.getMessageTtl()).isEqualTo(8); assertThat(result.getRate()).isEqualTo(200); }
private Subscription subscriptionWithTtl(int ttl) { return subscriptionBuilderWithTestValues() .withSubscriptionPolicy(subscriptionPolicy().applyDefaults() .withMessageTtl(ttl) .build()) .build(); }
private Subscription subscriptionWithBackoff(int backoff) { return subscriptionBuilderWithTestValues() .withSubscriptionPolicy(subscriptionPolicy().applyDefaults() .withMessageBackoff(backoff) .build()) .build(); }
private Subscription subscriptionWithout4xxRetryAndWithOAuthPolicy() { return subscriptionBuilderWithTestValues() .withOAuthPolicy(passwordGrantOAuthPolicy("myOAuthProvider") .withUsername("user1") .withPassword("abc123") .build()) .build(); }
private Subscription subscriptionWithTtlAndClientErrorRetry(int ttl) { return subscriptionBuilderWithTestValues() .withSubscriptionPolicy(subscriptionPolicy().applyDefaults() .withMessageTtl(ttl) .withClientErrorRetry() .build()) .build(); }
@Test public void shouldApplyPatchChangingSubscriptionOAuthPolicyGrantType() { // given Subscription subscription = subscription("group.topic", "subscription") .withOAuthPolicy(new SubscriptionOAuthPolicy(CLIENT_CREDENTIALS, "myProvider", "repo", null, null)) .build(); PatchData oAuthPolicyPatchData = patchData() .set("grantType", SubscriptionOAuthPolicy.GrantType.USERNAME_PASSWORD.getName()) .set("username", "user1") .set("password", "abc123") .build(); PatchData patch = patchData() .set("oAuthPolicy", oAuthPolicyPatchData) .build(); // when Subscription updated = Patch.apply(subscription, patch); // then SubscriptionOAuthPolicy updatedPolicy = updated.getOAuthPolicy(); assertThat(updatedPolicy.getGrantType()).isEqualTo(USERNAME_PASSWORD); assertThat(updatedPolicy.getUsername()).isEqualTo("user1"); } }
private SubscriptionName createSubscription(SubscriptionName subscriptionName) { Subscription subscription = subscription(subscriptionName).build(); Group group = Group.from(subscription.getTopicName().getGroupName()); if (!groupRepository.groupExists(group.getGroupName())) { groupRepository.createGroup(group); } if (!topicRepository.topicExists(subscription.getTopicName())) { topicRepository.createTopic(topic(subscription.getTopicName()).build()); } subscriptionRepository.createSubscription(subscription); await().atMost(adjust(ONE_SECOND)).until( () -> { subscriptionRepository.subscriptionExists(subscription.getTopicName(), subscription.getName()); subscriptionsCaches.forEach(subscriptionsCache -> subscriptionsCache.listActiveSubscriptionNames().contains(subscriptionName)); } ); return subscription.getQualifiedName(); }