public PomAssert hasProperty(String name, String value) { assertThat(this.properties).containsKeys(name); assertThat(this.properties).containsEntry(name, value); return this; }
@Test public void enableGlobalMethodSecurityDoesNotTriggerEagerInitializationOfBeansInGlobalAuthenticationConfigurer() { this.spring.register(Sec2815Config.class).autowire(); MockBeanPostProcessor pp = this.spring.getContext().getBean(MockBeanPostProcessor.class); assertThat(pp.beforeInit).containsKeys("dataSource"); assertThat(pp.afterInit).containsKeys("dataSource"); }
@Test public void propagatesSpan() throws Exception { server.enqueue(new MockResponse()); get(client, "/foo"); RecordedRequest request = server.takeRequest(); assertThat(request.getHeaders().toMultimap()) .containsKeys("x-b3-traceId", "x-b3-spanId") .containsEntry("x-b3-sampled", asList("1")); takeSpan(); }
public PomAssert hasRepository(String id, String name, String url, Boolean snapshotsEnabled) { assertThat(this.repositories).containsKeys(id); Repository repository = this.repositories.get(id); if (name != null) { assertThat(repository.getName()).isEqualTo(name); } if (url != null) { try { assertThat(repository.getUrl()).isEqualTo(new URL(url)); } catch (MalformedURLException ex) { throw new IllegalArgumentException("Cannot parse URL", ex); } } if (snapshotsEnabled) { assertThat(repository.isSnapshotsEnabled()).isEqualTo(snapshotsEnabled); } return this; }
@Test public void parseDeclarableWithClassAndProps() { String json = "{'k1':'v1','k2':'v2'}"; GfshParseResult result = parser.parse("create region --name=region --cache-writer=my.abc" + json); ClassName writer = (ClassName) result.getParamValue("cache-writer"); assertThat(writer.getClassName()).isEqualTo("my.abc"); assertThat(writer.getInitProperties()).containsKeys("k1", "k2"); }
@Test public void testElasticsearchDontExcludeCallTree() throws Exception { Mockito.when(tracingPlugin.getExcludeCallTreeFromReportWhenFasterThanXPercentOfRequests()).thenReturn(0d); reportSpanWithCallTree(250, "Report Me"); reportSpanWithCallTree(500, "Report Me"); reportSpanWithCallTree(1000, "Report Me"); final List<MockSpan> sampledSpans = getSampledSpans(); assertThat(sampledSpans).hasSize(3); sampledSpans.forEach(span -> assertThat(span.tags()).containsKeys(SpanUtils.CALL_TREE_ASCII, SpanUtils.CALL_TREE_JSON)); }
@Test public void issuerWhenAllInformationThenSuccess() throws Exception { ClientRegistration registration = registration(""); ClientRegistration.ProviderDetails provider = registration.getProviderDetails(); assertThat(registration.getClientAuthenticationMethod()).isEqualTo(ClientAuthenticationMethod.BASIC); assertThat(registration.getAuthorizationGrantType()).isEqualTo(AuthorizationGrantType.AUTHORIZATION_CODE); assertThat(registration.getRegistrationId()).isEqualTo(this.server.getHostName()); assertThat(registration.getClientName()).isEqualTo(this.issuer); assertThat(registration.getScopes()).containsOnly("openid", "email", "profile"); assertThat(provider.getAuthorizationUri()).isEqualTo("https://example.com/o/oauth2/v2/auth"); assertThat(provider.getTokenUri()).isEqualTo("https://example.com/oauth2/v4/token"); assertThat(provider.getJwkSetUri()).isEqualTo("https://example.com/oauth2/v3/certs"); assertThat(provider.getConfigurationMetadata()).containsKeys("authorization_endpoint", "claims_supported", "code_challenge_methods_supported", "id_token_signing_alg_values_supported", "issuer", "jwks_uri", "response_types_supported", "revocation_endpoint", "scopes_supported", "subject_types_supported", "grant_types_supported", "token_endpoint", "token_endpoint_auth_methods_supported", "userinfo_endpoint"); assertThat(provider.getUserInfoEndpoint().getUri()).isEqualTo("https://example.com/oauth2/v3/userinfo"); }
@Test public void parseServiceCreationConfiguration() throws SAXException, JAXBException, ParserConfigurationException, IOException, ClassNotFoundException { Configuration xmlConfig = new XmlConfiguration(getClass().getResource("/configs/thread-pools.xml")); assertThat(xmlConfig.getServiceCreationConfigurations()).hasSize(1); ServiceCreationConfiguration<?> configuration = xmlConfig.getServiceCreationConfigurations().iterator().next(); assertThat(configuration).isExactlyInstanceOf(PooledExecutionServiceConfiguration.class); PooledExecutionServiceConfiguration providerConfiguration = (PooledExecutionServiceConfiguration) configuration; assertThat(providerConfiguration.getPoolConfigurations()).containsKeys("big", "small"); PooledExecutionServiceConfiguration.PoolConfiguration small = providerConfiguration.getPoolConfigurations().get("small"); assertThat(small.minSize()).isEqualTo(1); assertThat(small.maxSize()).isEqualTo(1); PooledExecutionServiceConfiguration.PoolConfiguration big = providerConfiguration.getPoolConfigurations().get("big"); assertThat(big.minSize()).isEqualTo(4); assertThat(big.maxSize()).isEqualTo(32); assertThat(providerConfiguration.getDefaultPoolAlias()).isEqualTo("big"); }
@Test public void testElasticsearchExcludeFastCallTree() throws Exception { Mockito.when(tracingPlugin.getExcludeCallTreeFromReportWhenFasterThanXPercentOfRequests()).thenReturn(0.85d); reportSpanWithCallTree(1000, "Report Me"); assertThat(mockTracer.finishedSpans()).hasSize(1); assertThat(mockTracer.finishedSpans().get(0).tags()).containsKeys(SpanUtils.CALL_TREE_ASCII, SpanUtils.CALL_TREE_JSON); mockTracer.reset(); reportSpanWithCallTree(250, "Report Me"); assertThat(mockTracer.finishedSpans()).hasSize(1); assertThat(mockTracer.finishedSpans().get(0).tags()).doesNotContainKeys(SpanUtils.CALL_TREE_ASCII, SpanUtils.CALL_TREE_JSON); }
@Test public void xForwardedHeadersDoNotExist() throws Exception { MockServerHttpRequest request = MockServerHttpRequest .get("http://localhost:8080/get") .remoteAddress(new InetSocketAddress(InetAddress.getByName("10.0.0.1"), 80)) .header(HttpHeaders.HOST, "myhost") .build(); XForwardedHeadersFilter filter = new XForwardedHeadersFilter(); HttpHeaders headers = filter.filter(request.getHeaders(), MockServerWebExchange.from(request)); assertThat(headers).containsKeys(X_FORWARDED_FOR_HEADER, X_FORWARDED_HOST_HEADER, X_FORWARDED_PORT_HEADER, X_FORWARDED_PROTO_HEADER); assertThat(headers.getFirst(X_FORWARDED_FOR_HEADER)).isEqualTo("10.0.0.1"); assertThat(headers.getFirst(X_FORWARDED_HOST_HEADER)).isEqualTo("localhost:8080"); assertThat(headers.getFirst(X_FORWARDED_PORT_HEADER)).isEqualTo("8080"); assertThat(headers.getFirst(X_FORWARDED_PROTO_HEADER)).isEqualTo("http"); }
@Test public void defaultPort() throws Exception { MockServerHttpRequest request = MockServerHttpRequest .get("http://localhost/get") .remoteAddress(new InetSocketAddress(InetAddress.getByName("10.0.0.1"), 80)) .header(HttpHeaders.HOST, "myhost") .build(); XForwardedHeadersFilter filter = new XForwardedHeadersFilter(); HttpHeaders headers = filter.filter(request.getHeaders(), MockServerWebExchange.from(request)); assertThat(headers).containsKeys(X_FORWARDED_FOR_HEADER, X_FORWARDED_HOST_HEADER, X_FORWARDED_PORT_HEADER, X_FORWARDED_PROTO_HEADER); assertThat(headers.getFirst(X_FORWARDED_FOR_HEADER)).isEqualTo("10.0.0.1"); assertThat(headers.getFirst(X_FORWARDED_HOST_HEADER)).isEqualTo("localhost"); assertThat(headers.getFirst(X_FORWARDED_PORT_HEADER)).isEqualTo("80"); assertThat(headers.getFirst(X_FORWARDED_PROTO_HEADER)).isEqualTo("http"); }
/** Unlike Brave 3, Brave 4 propagates trace ids even when unsampled */ @Test public void propagates_sampledFalse() throws Exception { close(); httpTracing = HttpTracing.create(tracingBuilder(Sampler.NEVER_SAMPLE).build()); client = newClient(server.getPort()); server.enqueue(new MockResponse()); get(client, "/foo"); RecordedRequest request = server.takeRequest(); assertThat(request.getHeaders().toMultimap()) .containsKeys("x-b3-traceId", "x-b3-spanId") .doesNotContainKey("x-b3-parentSpanId") .containsEntry("x-b3-sampled", asList("0")); }
@Test public void remoteAddressIsNull() throws Exception { MockServerHttpRequest request = MockServerHttpRequest .get("http://localhost:8080/get") .header(HttpHeaders.HOST, "myhost") .build(); XForwardedHeadersFilter filter = new XForwardedHeadersFilter(); HttpHeaders headers = filter.filter(request.getHeaders(), MockServerWebExchange.from(request)); assertThat(headers).containsKeys(X_FORWARDED_HOST_HEADER, X_FORWARDED_PORT_HEADER, X_FORWARDED_PROTO_HEADER); assertThat(headers.getFirst(X_FORWARDED_HOST_HEADER)).isEqualTo("localhost:8080"); assertThat(headers.getFirst(X_FORWARDED_PORT_HEADER)).isEqualTo("8080"); assertThat(headers.getFirst(X_FORWARDED_PROTO_HEADER)).isEqualTo("http"); }
@Test public void getTrackedMessages() throws Exception { Map<Long, Map<Long, EhcacheEntityResponse>> result = message.getTrackedMessages(); assertThat(result).containsKeys(id1.toLong(), id2.toLong()); assertThat(result.get(id1.toLong())).contains(entry(3L, r3), entry(4L, r4)); assertThat(result.get(id2.toLong())).contains(entry(5L, r5)); }
@Test public void add() { final String key = map.generateKey(task); map.add(task, 1); assertThat(keyToIdMap).containsKeys(key); assertThat(keyToIdMap).containsValues(1); assertThat(idToKeyMap.size()).isOne(); assertThat(idToKeyMap.get(1)).isEqualTo(key); } }
@Test public void appendsValues() throws Exception { MockServerHttpRequest request = MockServerHttpRequest .get("http://localhost:8080/get") .remoteAddress(new InetSocketAddress(InetAddress.getByName("10.0.0.1"), 80)) .header(X_FORWARDED_FOR_HEADER, "192.168.0.2") .header(X_FORWARDED_HOST_HEADER, "example.com") .header(X_FORWARDED_PORT_HEADER, "443") .header(X_FORWARDED_PROTO_HEADER, "https") .build(); XForwardedHeadersFilter filter = new XForwardedHeadersFilter(); HttpHeaders headers = filter.filter(request.getHeaders(), MockServerWebExchange.from(request)); assertThat(headers).containsKeys(X_FORWARDED_FOR_HEADER, X_FORWARDED_HOST_HEADER, X_FORWARDED_PORT_HEADER, X_FORWARDED_PROTO_HEADER); assertThat(headers.getFirst(X_FORWARDED_FOR_HEADER)).isEqualTo("192.168.0.2,10.0.0.1"); assertThat(headers.getFirst(X_FORWARDED_HOST_HEADER)).isEqualTo("example.com,localhost:8080"); assertThat(headers.getFirst(X_FORWARDED_PORT_HEADER)).isEqualTo("443,8080"); assertThat(headers.getFirst(X_FORWARDED_PROTO_HEADER)).isEqualTo("https,http"); }
@Test public void testInternalTags() throws Exception { spanWrappingTracer.buildSpan("test") .withTag(SpanWrapper.INTERNAL_TAG_PREFIX + "foo", "foo") .withTag("foo", "foo") .start() .setTag(SpanWrapper.INTERNAL_TAG_PREFIX + "bar", "bar") .setTag("bar", "bar") .finish(); final List<MockSpan> mockSpans = mockTracer.finishedSpans(); assertThat(mockSpans).hasSize(1); final Map<String, Object> tags = mockSpans.get(0).tags(); assertThat(tags).doesNotContainKeys(SpanWrapper.INTERNAL_TAG_PREFIX + "foo", SpanWrapper.INTERNAL_TAG_PREFIX + "bar"); assertThat(tags).containsKeys("foo", "bar"); } }
@Test public void selectLatestDelivery_of_a_webhook() { WebhookDto webhook1 = dbWebhooks.insert(newProjectWebhook("COMPONENT_1")); underTest.insert(dbSession, WebhookDeliveryTesting.newDto("WH1-DELIVERY-1-UUID", webhook1.getUuid(), "COMPONENT_1", "TASK_1").setCreatedAt(BEFORE)); underTest.insert(dbSession, WebhookDeliveryTesting.newDto("WH1-DELIVERY-2-UUID", webhook1.getUuid(), "COMPONENT_1", "TASK_2").setCreatedAt(NOW)); WebhookDto webhook2 = dbWebhooks.insert(newProjectWebhook("COMPONENT_1")); underTest.insert(dbSession, WebhookDeliveryTesting.newDto("WH2-DELIVERY-1-UUID", webhook2.getUuid(), "COMPONENT_1", "TASK_1").setCreatedAt(BEFORE)); underTest.insert(dbSession, WebhookDeliveryTesting.newDto("WH2-DELIVERY-2-UUID", webhook2.getUuid(), "COMPONENT_1", "TASK_2").setCreatedAt(NOW)); Map<String, WebhookDeliveryLiteDto> map = underTest.selectLatestDeliveries(dbSession, of(webhook1, webhook2)); assertThat(map).containsKeys(webhook1.getUuid()); assertThat(map.get(webhook1.getUuid())).extracting(WebhookDeliveryLiteDto::getUuid).contains("WH1-DELIVERY-2-UUID"); assertThat(map).containsKeys(webhook2.getUuid()); assertThat(map.get(webhook2.getUuid())).extracting(WebhookDeliveryLiteDto::getUuid).contains("WH2-DELIVERY-2-UUID"); }
@Test public void collectMultiMap() { StepVerifier.create(Flux.just(new Pojo("test", 1L), new Pojo("test", 2L), new Pojo("test2", 3L)) .collectMultimap(p -> p.name)) .assertNext(d -> assertThat(d).containsKeys("test", "test2") .containsValues(Arrays.asList(new Pojo( "test", 1L), new Pojo("test", 2L)), Arrays.asList(new Pojo("test2", 3L)))) .verifyComplete(); }
@Test public void collectMap() { StepVerifier.create(Flux.just(new Pojo("test", 1L), new Pojo("test", 2L), new Pojo("test2", 3L)) .collectMap(p -> p.id)) .assertNext(d -> assertThat(d).containsKeys(1L, 2L, 3L) .containsValues(new Pojo("test", 1L), new Pojo("test", 2L), new Pojo("test2", 3L))) .verifyComplete(); }