Java Code Examples for org.springframework.boot.WebApplicationType

The following examples show how to use org.springframework.boot.WebApplicationType. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
@Test
public void environmentEnrichedInParentContext() {
	PropertySourceConfiguration.MAP.put("bootstrap.foo", "bar");
	this.context = new SpringApplicationBuilder().sources(BareConfiguration.class)
			.child(BareConfiguration.class).web(WebApplicationType.NONE).run();
	then(this.context.getEnvironment().getProperty("bootstrap.foo")).isEqualTo("bar");
	then(this.context.getParent().getEnvironment())
			.isNotSameAs(this.context.getEnvironment());
	then(this.context.getEnvironment().getPropertySources().contains(
			PropertySourceBootstrapConfiguration.BOOTSTRAP_PROPERTY_SOURCE_NAME
					+ "-testBootstrap")).isTrue();
	then(((ConfigurableEnvironment) this.context.getParent().getEnvironment())
			.getPropertySources().contains(
					PropertySourceBootstrapConfiguration.BOOTSTRAP_PROPERTY_SOURCE_NAME
							+ "-testBootstrap")).isTrue();
}
 
Example 2
Source Project: spring-cloud-stream   Source File: ContentTypeTckTests.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void typelessMessageToPojoInboundContentTypeBindingJson() {
	ApplicationContext context = new SpringApplicationBuilder(
			TypelessMessageToPojoStreamListener.class).web(WebApplicationType.NONE)
					.run("--spring.cloud.stream.bindings.input.contentType=application/json",
							"--spring.jmx.enabled=false");
	InputDestination source = context.getBean(InputDestination.class);
	OutputDestination target = context.getBean(OutputDestination.class);
	String jsonPayload = "{\"name\":\"oleg\"}";
	source.send(new GenericMessage<>(jsonPayload.getBytes()));
	Message<byte[]> outputMessage = target.receive();
	assertThat(outputMessage.getHeaders().get(MessageHeaders.CONTENT_TYPE))
			.isEqualTo(MimeTypeUtils.APPLICATION_JSON);
	assertThat(new String(outputMessage.getPayload(), StandardCharsets.UTF_8))
			.isEqualTo(jsonPayload);
}
 
Example 3
private ConfigurableApplicationContext multipleStream() {
	System.setProperty("logging.level.org.apache.kafka", "OFF");
	SpringApplication app = new SpringApplication(AnotherKStreamApplication.class);
	app.setWebApplicationType(WebApplicationType.NONE);
	return app.run("--server.port=0", "--spring.jmx.enabled=false",
			"--spring.cloud.stream.bindings.input.destination=in",
			"--spring.cloud.stream.bindings.output.destination=out",
			"--spring.cloud.stream.bindings.input2.destination=in2",
			"--spring.cloud.stream.bindings.output2.destination=out2",
			"--spring.cloud.stream.kafka.streams.binder.configuration.commit.interval.ms=1000",
			"--spring.cloud.stream.kafka.streams.binder.configuration.default.key.serde="
					+ "org.apache.kafka.common.serialization.Serdes$StringSerde",
			"--spring.cloud.stream.kafka.streams.binder.configuration.default.value.serde="
					+ "org.apache.kafka.common.serialization.Serdes$StringSerde",
			"--spring.cloud.stream.kafka.streams.bindings.input.consumer.applicationId="
					+ "ApplicationHealthTest-xyz",
			"--spring.cloud.stream.kafka.streams.bindings.input2.consumer.applicationId="
					+ "ApplicationHealthTest2-xyz",
			"--spring.cloud.stream.kafka.streams.binder.brokers="
					+ embeddedKafka.getBrokersAsString());
}
 
Example 4
@Test
public void testSimpleFunctionWithNativeProperty() {

	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(
			TestChannelBinderConfiguration.getCompleteConfiguration(NoEnableBindingConfiguration.class))
					.web(WebApplicationType.NONE)
					.run("--spring.jmx.enabled=false", "--spring.cloud.function.definition=func")) {

		InputDestination inputDestination = context.getBean(InputDestination.class);
		OutputDestination outputDestination = context.getBean(OutputDestination.class);

		Message<byte[]> inputMessage = MessageBuilder.withPayload("Hello".getBytes()).build();
		inputDestination.send(inputMessage);

		Message<byte[]> outputMessage = outputDestination.receive();
		assertThat(outputMessage.getPayload()).isEqualTo("Hello".getBytes());

	}
}
 
Example 5
@Test
public void partitionOnOutputPayloadTestReactive() {
	System.clearProperty("spring.cloud.function.definition");
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(TestChannelBinderConfiguration
			.getCompleteConfiguration(PojoFunctionConfiguration.class))
					.web(WebApplicationType.NONE).run("--spring.cloud.function.definition=funcReactive",
							"--spring.cloud.stream.bindings.funcReactive-out-0.producer.partitionKeyExpression=payload.id",
							"--spring.cloud.stream.bindings.funcReactive-out-0.producer.partitionCount=5",
							"--spring.jmx.enabled=false")) {

		InputDestination inputDestination = context.getBean(InputDestination.class);
		OutputDestination outputDestination = context.getBean(OutputDestination.class);

		Message<byte[]> inputMessage = MessageBuilder.withPayload("Jim Lahey".getBytes()).build();

		inputDestination.send(inputMessage, "funcReactive-in-0");

		assertThat(outputDestination.receive(100, "funcReactive-out-0").getHeaders().get("scst_partition")).isEqualTo(3);

		assertThat(outputDestination.receive(100)).isNull();
	}
}
 
Example 6
@Test
public void mappingRepo() throws IOException {
	String defaultRepoUri = ConfigServerTestUtils.prepareLocalRepo("config-repo");
	String test1RepoUri = ConfigServerTestUtils.prepareLocalRepo("test1-config-repo");

	Map<String, Object> repoMapping = new LinkedHashMap<String, Object>();
	repoMapping.put("spring.cloud.config.server.git.repos[test1].pattern", "*test1*");
	repoMapping.put("spring.cloud.config.server.git.repos[test1].uri", test1RepoUri);
	this.context = new SpringApplicationBuilder(TestConfiguration.class)
			.web(WebApplicationType.NONE)
			.properties("spring.cloud.config.server.git.uri:" + defaultRepoUri)
			.properties(repoMapping).run();
	EnvironmentRepository repository = this.context
			.getBean(EnvironmentRepository.class);
	Environment environment = repository.findOne("test1-svc", "staging", "master");
	assertThat(environment.getPropertySources().size()).isEqualTo(2);
}
 
Example 7
Source Project: spring-cloud-stream   Source File: ContentTypeTckTests.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void typelessToPojoInboundContentTypeBindingJson() {
	ApplicationContext context = new SpringApplicationBuilder(
			TypelessToPojoStreamListener.class).web(WebApplicationType.NONE).run(
					"--spring.cloud.stream.bindings.input.contentType=application/json",
					"--spring.jmx.enabled=false");
	InputDestination source = context.getBean(InputDestination.class);
	OutputDestination target = context.getBean(OutputDestination.class);
	String jsonPayload = "{\"name\":\"oleg\"}";
	source.send(new GenericMessage<>(jsonPayload.getBytes()));
	Message<byte[]> outputMessage = target.receive();
	assertThat(outputMessage.getHeaders().get(MessageHeaders.CONTENT_TYPE))
			.isEqualTo(MimeTypeUtils.APPLICATION_JSON);
	assertThat(new String(outputMessage.getPayload(), StandardCharsets.UTF_8))
			.isEqualTo(jsonPayload);
}
 
Example 8
@Test
public void testSingleInputMultiOutput() {
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(
			TestChannelBinderConfiguration.getCompleteConfiguration(
					ReactiveFunctionConfiguration.class))
							.web(WebApplicationType.NONE)
							.run("--spring.jmx.enabled=false",
								"--spring.cloud.function.definition=singleInputMultipleOutputs")) {
		context.getBean(InputDestination.class);

		InputDestination inputDestination = context.getBean(InputDestination.class);
		OutputDestination outputDestination = context.getBean(OutputDestination.class);

		for (int i = 0; i < 10; i++) {
			inputDestination.send(MessageBuilder.withPayload(String.valueOf(i).getBytes()).build(), "singleInputMultipleOutputs-in-0");
		}

		int counter = 0;
		for (int i = 0; i < 5; i++) {
			Message<byte[]> even = outputDestination.receive(0, "singleInputMultipleOutputs-out-0");
			assertThat(even.getPayload()).isEqualTo(("EVEN: " + String.valueOf(counter++)).getBytes());
			Message<byte[]> odd = outputDestination.receive(0, "singleInputMultipleOutputs-out-1");
			assertThat(odd.getPayload()).isEqualTo(("ODD: " + String.valueOf(counter++)).getBytes());
		}
	}
}
 
Example 9
@Test
public void testReactiveFunctionWithOutputAsMonoVoid() {
	System.clearProperty("spring.cloud.function.definition");
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(
			TestChannelBinderConfiguration.getCompleteConfiguration(FunctionalConsumerConfiguration.class))
					.web(WebApplicationType.NONE).run("--spring.jmx.enabled=false")) {

		assertThat(context.containsBean("funcConsumer-out-0")).isFalse();
		InputDestination inputDestination = context.getBean(InputDestination.class);
		Message<byte[]> inputMessage = MessageBuilder.withPayload("Hello".getBytes()).build();
		inputDestination.send(inputMessage);

		assertThat(System.getProperty("consumer")).isEqualTo("Hello");
		System.clearProperty("consumer");
	}
}
 
Example 10
Source Project: spring-cloud-stream   Source File: RetryTemplateTests.java    License: Apache License 2.0 6 votes vote down vote up
@SuppressWarnings("rawtypes")
@Test
public void testSpecificCustomRetryTemplate() throws Exception {
	ApplicationContext context = new SpringApplicationBuilder(
			SpecificCustomRetryTemplateConfiguration.class)
					.web(WebApplicationType.NONE).run("--spring.jmx.enabled=false",
							"--spring.cloud.stream.bindings.input.consumer.retry-template-name=retryTemplateTwo");

	RetryTemplate retryTemplateTwo = context.getBean("retryTemplateTwo",
			RetryTemplate.class);
	BindingServiceProperties bindingServiceProperties = context
			.getBean(BindingServiceProperties.class);
	ConsumerProperties consumerProperties = bindingServiceProperties
			.getConsumerProperties("input");
	AbstractBinder binder = context.getBean(AbstractBinder.class);

	Method m = AbstractBinder.class.getDeclaredMethod("buildRetryTemplate",
			ConsumerProperties.class);
	m.setAccessible(true);
	RetryTemplate retryTemplate = (RetryTemplate) m.invoke(binder,
			consumerProperties);
	assertThat(retryTemplate).isEqualTo(retryTemplateTwo);
}
 
Example 11
@Test
public void testMetricsWorkWithMultiBinders() {
	ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder(
			SimpleApplication.class).web(WebApplicationType.NONE).run(
					"--spring.cloud.stream.bindings.input.destination=foo",
					"--spring.cloud.stream.bindings.input.binder=inbound",
					"--spring.cloud.stream.bindings.input.group=testGroupabc",
					"--spring.cloud.stream.binders.inbound.type=kafka",
					"--spring.cloud.stream.binders.inbound.environment"
							+ ".spring.cloud.stream.kafka.binder.brokers" + "="
							+ embeddedKafka.getEmbeddedKafka().getBrokersAsString());

	final MeterRegistry meterRegistry = applicationContext.getBean(MeterRegistry.class);

	assertThat(meterRegistry).isNotNull();

	assertThat(meterRegistry.get("spring.cloud.stream.binder.kafka.offset")
			.tag("group", "testGroupabc")
			.tag("topic", "foo").gauge().value()).isNotNull();

	applicationContext.close();
}
 
Example 12
@Test
public void nonExistentKeystoreLocationShouldNotBeAllowed() {
	try {
		new SpringApplicationBuilder(EncryptionBootstrapConfiguration.class)
				.web(WebApplicationType.NONE)
				.properties("encrypt.key-store.location:classpath:/server.jks1",
						"encrypt.key-store.password:letmein",
						"encrypt.key-store.alias:mytestkey",
						"encrypt.key-store.secret:changeme")
				.run();
		then(false).as(
				"Should not create an application context with invalid keystore location")
				.isTrue();
	}
	catch (Exception e) {
		then(e).hasRootCauseInstanceOf(IllegalStateException.class);
	}
}
 
Example 13
Source Project: spring-cloud-stream   Source File: ContentTypeTckTests.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void stringToPojoInboundContentTypeBinding() {
	ApplicationContext context = new SpringApplicationBuilder(
			StringToPojoStreamListener.class).web(WebApplicationType.NONE).run(
					"--spring.cloud.stream.bindings.input.contentType=text/plain",
					"--spring.jmx.enabled=false");
	InputDestination source = context.getBean(InputDestination.class);
	OutputDestination target = context.getBean(OutputDestination.class);
	String jsonPayload = "{\"name\":\"oleg\"}";
	source.send(new GenericMessage<>(jsonPayload.getBytes()));
	Message<byte[]> outputMessage = target.receive();
	assertThat(outputMessage.getHeaders().get(MessageHeaders.CONTENT_TYPE))
			.isEqualTo(MimeTypeUtils.APPLICATION_JSON);
	assertThat(new String(outputMessage.getPayload(), StandardCharsets.UTF_8))
			.isEqualTo(jsonPayload);
}
 
Example 14
Source Project: cloudbreak   Source File: IntegrationTestApp.java    License: Apache License 2.0 6 votes vote down vote up
public static void main(String[] args) {
    long start = System.currentTimeMillis();
    SpringApplication springApp = new SpringApplication(IntegrationTestApp.class);
    springApp.setWebApplicationType(WebApplicationType.NONE);
    springApp.setDefaultProperties(ImmutableMap.of("spring.main.allow-bean-definition-overriding", "true"));
    try {
        ConfigurableApplicationContext context = springApp.run(args);
        LOG.info("Closing Spring test context.");
        context.close();
        LOG.info("Tests have been done successfully: {} milliseconds", System.currentTimeMillis() - start);
        System.exit(0);
    } catch (Exception e) {
        LOG.error("Exception occurred during closing Spring Context: {}", e.getMessage(), e);
        Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
        threadSet.stream().forEach(t -> LOG.info("Running threads: {}", t.getName()));
        System.exit(1);
    }
}
 
Example 15
Source Project: spring-cloud-stream   Source File: StreamBridgeTests.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testSendingMessageToOutputOfExistingSupplier() {
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(TestChannelBinderConfiguration
			.getCompleteConfiguration(TestConfiguration.class))
					.web(WebApplicationType.NONE).run("--spring.cloud.stream.source=supplier;foo",
							"--spring.jmx.enabled=false")) {

		StreamBridge bridge = context.getBean(StreamBridge.class);
		bridge.send("supplier-out-0", "blah");
		bridge.send("foo-out-0", "b");


		OutputDestination outputDestination = context.getBean(OutputDestination.class);
		Message<byte[]> message = outputDestination.receive(100, "foo-out-0");
		assertThat(new String(message.getPayload())).isEqualTo("b");
		message = outputDestination.receive(100, "supplier-out-0");
		assertThat(new String(message.getPayload())).isEqualTo("hello");
		message = outputDestination.receive(100, "supplier-out-0");
		assertThat(new String(message.getPayload())).isEqualTo("blah");
	}
}
 
Example 16
@Test
public void contentTypeAsByteArrayTest() {
	System.clearProperty("spring.cloud.function.definition");
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(TestChannelBinderConfiguration
			.getCompleteConfiguration(PojoFunctionConfiguration.class))
					.web(WebApplicationType.NONE).run("--spring.cloud.function.definition=echoPerson",
							"--spring.jmx.enabled=false")) {

		InputDestination inputDestination = context.getBean(InputDestination.class);
		OutputDestination outputDestination = context.getBean(OutputDestination.class);

		Message<byte[]> inputMessage = MessageBuilder.withPayload("{\"name\":\"Jim Lahey\",\"id\":420}".getBytes())
				.setHeader(MessageHeaders.CONTENT_TYPE, "application/json".getBytes(StandardCharsets.UTF_8))
				.build();

		inputDestination.send(inputMessage, "echoPerson-in-0");

		assertThat(outputDestination.receive(100, "echoPerson-out-0").getPayload()).isEqualTo("{\"name\":\"Jim Lahey\",\"id\":420}".getBytes());
	}
}
 
Example 17
@Test
public void testWithContextTypeApplicationProperty() {
	System.clearProperty("spring.cloud.function.definition");
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(
			TestChannelBinderConfiguration.getCompleteConfiguration(SingleFunctionConfiguration.class))
					.web(WebApplicationType.NONE).run("--spring.jmx.enabled=false",
							"--spring.cloud.stream.bindings.input.content-type=text/plain", "--debug")) {

		InputDestination inputDestination = context.getBean(InputDestination.class);
		OutputDestination outputDestination = context.getBean(OutputDestination.class);

		Message<byte[]> inputMessageOne = MessageBuilder.withPayload("Hello".getBytes()).build();
		Message<byte[]> inputMessageTwo = MessageBuilder.withPayload("Hello Again".getBytes()).build();
		inputDestination.send(inputMessageOne);
		inputDestination.send(inputMessageTwo);

		Message<byte[]> outputMessage = outputDestination.receive();
		assertThat(outputMessage.getPayload()).isEqualTo("Hello".getBytes());
		outputMessage = outputDestination.receive();
		assertThat(outputMessage.getPayload()).isEqualTo("Hello Again".getBytes());
	}
}
 
Example 18
@Test
public void testMultiInputSingleOutputWithCustomContentType() {
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(
			TestChannelBinderConfiguration.getCompleteConfiguration(
					ContentTypeConfiguration.class))
							.web(WebApplicationType.NONE)
							.run("--spring.jmx.enabled=false",
								"--spring.cloud.function.definition=multiInputSingleOutput",
								"--spring.cloud.stream.bindings.multiInputSingleOutput-in-0.content-type=string/person",
								"--spring.cloud.stream.bindings.multiInputSingleOutput-in-1.content-type=string/employee")) {
		context.getBean(InputDestination.class);

		InputDestination inputDestination = context.getBean(InputDestination.class);
		OutputDestination outputDestination = context.getBean(OutputDestination.class);

		Message<byte[]> stringInputMessage = MessageBuilder.withPayload("ricky".getBytes()).build();
		Message<byte[]> integerInputMessage = MessageBuilder.withPayload("bobby".getBytes()).build();
		inputDestination.send(stringInputMessage, "multiInputSingleOutput-in-0");
		inputDestination.send(integerInputMessage, "multiInputSingleOutput-in-1");

		Message<byte[]> outputMessage = outputDestination.receive(1000, "multiInputSingleOutput-out-0");
		assertThat(outputMessage.getPayload()).isEqualTo("RICKY".getBytes());
		outputMessage = outputDestination.receive(1000, "multiInputSingleOutput-out-0");
		assertThat(outputMessage.getPayload()).isEqualTo("BOBBY".getBytes());
	}
}
 
Example 19
@Test
public void nestedPropertySource() {
	// Prepare context
	Map<String, Object> props = new HashMap<>();
	props.put("spring.data.mongodb.database", "testdb");
	context = new SpringApplicationBuilder(TestConfiguration.class).web(WebApplicationType.NONE).properties(props).run();
	// Prepare test
	MongoTemplate mongoTemplate = this.context.getBean(MongoTemplate.class);
	mongoTemplate.dropCollection("testapp");
	MongoPropertySource ps = new MongoPropertySource();
	Map<String, String> inner = new HashMap<String, String>();
	inner.put("inner", "value");
	ps.getSource().put("outer", inner);
	mongoTemplate.save(ps, "testapp");
	// Test
	EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class);
	Environment environment = repository.findOne("testapp", "default", null);
	assertEquals("testapp-default", environment.getPropertySources().get(0).getName());
	assertEquals(1, environment.getPropertySources().size());
	assertEquals(true, environment.getPropertySources().get(0).getSource().containsKey("outer.inner"));
	assertEquals("value", environment.getPropertySources().get(0).getSource().get("outer.inner"));
}
 
Example 20
@Test
public void testSimpleFunctionWithStreamProperty() {

	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(
			TestChannelBinderConfiguration.getCompleteConfiguration(NoEnableBindingConfiguration.class))
					.web(WebApplicationType.NONE)
					.run("--spring.jmx.enabled=false", "--spring.cloud.function.definition=func")) {

		InputDestination inputDestination = context.getBean(InputDestination.class);
		OutputDestination outputDestination = context.getBean(OutputDestination.class);

		Message<byte[]> inputMessage = MessageBuilder.withPayload("Hello".getBytes()).build();
		inputDestination.send(inputMessage);

		Message<byte[]> outputMessage = outputDestination.receive();
		assertThat(outputMessage.getPayload()).isEqualTo("Hello".getBytes());

	}
}
 
Example 21
@Test
public void testFiniteFluxSupplierSimple() {
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(
			TestChannelBinderConfiguration.getCompleteConfiguration(FunctionsConfiguration.class,
					SimpleFluxSupplierConfiguration.class)).web(WebApplicationType.NONE).run(
							"--spring.cloud.stream.function.definition=simpleStreamSupplier",
							"--spring.jmx.enabled=false")) {

		OutputDestination target = context.getBean(OutputDestination.class);

		assertThat(new String(target.receive(2000).getPayload())).isEqualTo("1");
		assertThat(new String(target.receive(2000).getPayload())).isEqualTo("2");
		assertThat(new String(target.receive(2000).getPayload())).isEqualTo("3");
		assertThat(new String(target.receive(2000).getPayload())).isEqualTo("4");
		assertThat(new String(target.receive(2000).getPayload())).isEqualTo("5");
		assertThat(new String(target.receive(2000).getPayload())).isEqualTo("6");

		//assertThat(context.getBean("supplierInitializer")).isNotEqualTo(null);
	}
}
 
Example 22
@Test
public void partitionOnOutputPayloadWithReactiveSupplierTest() {
	System.clearProperty("spring.cloud.function.definition");
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(TestChannelBinderConfiguration
			.getCompleteConfiguration(PojoFunctionConfiguration.class))
					.web(WebApplicationType.NONE).run("--spring.cloud.function.definition=reactivePersonSupplier",
							"--spring.cloud.stream.bindings.reactivePersonSupplier-out-0.producer.partitionKeyExpression=payload.id",
							"--spring.cloud.stream.bindings.reactivePersonSupplier-out-0.producer.partitionCount=5",
							"--spring.jmx.enabled=false")) {

		OutputDestination outputDestination = context.getBean(OutputDestination.class);

		assertThat(outputDestination.receive(1000, "reactivePersonSupplier-out-0").getHeaders().get("scst_partition")).isEqualTo(1);

		assertThat(outputDestination.receive(100)).isNull();
	}
}
 
Example 23
@Test
public void includeProfileFromBootstrapPropertySource() {
	PropertySourceConfiguration.MAP.put("spring.profiles.include", "bar,baz");
	this.context = new SpringApplicationBuilder().web(WebApplicationType.NONE)
			.profiles("foo").sources(BareConfiguration.class).run();
	then(this.context.getEnvironment().acceptsProfiles("baz")).isTrue();
	then(this.context.getEnvironment().acceptsProfiles("bar")).isTrue();
}
 
Example 24
@Test
public void failsOnPropertySource() {
	System.setProperty("expected.fail", "true");
	this.expected.expectMessage("Planned");
	this.context = new SpringApplicationBuilder().web(WebApplicationType.NONE)
			.sources(BareConfiguration.class).run();
}
 
Example 25
Source Project: spring-cloud-commons   Source File: RefreshEndpointTests.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void keysComputedWhenAdded() throws Exception {
	this.context = new SpringApplicationBuilder(Empty.class)
			.web(WebApplicationType.NONE).bannerMode(Mode.OFF)
			.properties("spring.cloud.bootstrap.name:none").run();
	RefreshScope scope = new RefreshScope();
	scope.setApplicationContext(this.context);
	this.context.getEnvironment().setActiveProfiles("local");
	ContextRefresher contextRefresher = new ContextRefresher(this.context, scope);
	RefreshEndpoint endpoint = new RefreshEndpoint(contextRefresher);
	Collection<String> keys = endpoint.refresh();
	then(keys.contains("added")).isTrue().as("Wrong keys: " + keys);
}
 
Example 26
@Test
public void symmetricConfigurationProperties() {
	ConfigurableApplicationContext context = new SpringApplicationBuilder(
			TestConfiguration.class).web(WebApplicationType.NONE).properties(
					"encrypt.key:pie",
					"foo.password:{cipher}bf29452295df354e6153c5b31b03ef23c70e55fba24299aa85c63438f1c43c95")
					.run();
	then(context.getBean(PasswordProperties.class).getPassword()).isEqualTo("test");
}
 
Example 27
Source Project: gemini   Source File: IntegrationTestMain.java    License: Apache License 2.0 5 votes vote down vote up
public static ConfigurableApplicationContext initializeFullIntegrationWebApp(Set<Class> coreBean, Set<Class> apiBean) {
    ConfigurableApplicationContext root = initializeGemini(coreBean.toArray(new Class[0]));
    ConfigurableApplicationContext webApp = new SpringApplicationBuilder()
            .parent(root).sources(Api.class, Autoconfiguration.class).sources(apiBean.toArray(new Class[0]))
            .web(WebApplicationType.SERVLET)
            .bannerMode(Banner.Mode.OFF)
            .run();
    return webApp;
}
 
Example 28
@Test
public void testKstreamWordCountFunctionWithCustomProducerStreamPartitioner() throws Exception {
	SpringApplication app = new SpringApplication(WordCountProcessorApplication.class);
	app.setWebApplicationType(WebApplicationType.NONE);

	try (ConfigurableApplicationContext context = app.run(
			"--server.port=0",
			"--spring.jmx.enabled=false",
			"--spring.cloud.stream.bindings.process-in-0.destination=words-2",
			"--spring.cloud.stream.bindings.process-out-0.destination=counts-2",
			"--spring.cloud.stream.bindings.process-out-0.producer.partitionCount=2",
			"--spring.cloud.stream.kafka.streams.bindings.process-out-0.producer.streamPartitionerBeanName" +
					"=streamPartitioner",
			"--spring.cloud.stream.kafka.streams.binder.configuration.commit.interval.ms=1000",
			"--spring.cloud.stream.kafka.streams.binder.configuration.default.key.serde" +
					"=org.apache.kafka.common.serialization.Serdes$StringSerde",
			"--spring.cloud.stream.kafka.streams.binder.configuration.default.value.serde" +
					"=org.apache.kafka.common.serialization.Serdes$StringSerde",
			"--spring.cloud.stream.kafka.streams.binder.brokers=" + embeddedKafka.getBrokersAsString())) {
		Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
		DefaultKafkaProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
		try {
			KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf, true);
			template.setDefaultTopic("words-2");
			template.sendDefault("foo");
			ConsumerRecord<String, String> cr = KafkaTestUtils.getSingleRecord(consumer, "counts-2");
			assertThat(cr.value().contains("\"word\":\"foo\",\"count\":1")).isTrue();
			assertThat(cr.partition() == 0) .isTrue();
			template.sendDefault("bar");
			cr = KafkaTestUtils.getSingleRecord(consumer, "counts-2");
			assertThat(cr.value().contains("\"word\":\"bar\",\"count\":1")).isTrue();
			assertThat(cr.partition() == 1) .isTrue();
		}
		finally {
			pf.destroy();
		}
	}
}
 
Example 29
Source Project: spring-cloud-stream   Source File: ContentTypeTckTests.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void byteArrayToByteArray() {
	ApplicationContext context = new SpringApplicationBuilder(
			ByteArrayToByteArrayStreamListener.class).web(WebApplicationType.NONE)
					.run("--spring.jmx.enabled=false");
	InputDestination source = context.getBean(InputDestination.class);
	OutputDestination target = context.getBean(OutputDestination.class);
	String jsonPayload = "{\"name\":\"oleg\"}";
	source.send(new GenericMessage<>(jsonPayload.getBytes()));
	Message<byte[]> outputMessage = target.receive();
	assertThat(new String(outputMessage.getPayload(), StandardCharsets.UTF_8))
			.isEqualTo(jsonPayload);
}
 
Example 30
@Test
public void testServiceDefinitionToConsulRegistration() throws Exception {
    final ZookeeperServer server = new ZookeeperServer(temporaryFolder.newFolder(testName.getMethodName()));

    ConfigurableApplicationContext context = new SpringApplicationBuilder(TestConfiguration.class)
        .web(WebApplicationType.NONE)
        .run(
            "--debug=false",
            "--spring.main.banner-mode=OFF",
            "--spring.application.name=" + UUID.randomUUID().toString(),
            "--ribbon.enabled=false",
            "--ribbon.eureka.enabled=false",
            "--management.endpoint.enabled=false",
            "--spring.cloud.zookeeper.enabled=true",
            "--spring.cloud.zookeeper.connect-string=" + server.connectString(),
            "--spring.cloud.zookeeper.config.enabled=false",
            "--spring.cloud.zookeeper.discovery.enabled=true",
            "--spring.cloud.service-registry.auto-registration.enabled=false"
        );

    try {
        Map<String, Converter> converters = context.getBeansOfType(Converter.class);

        assertThat(converters).isNotNull();
        assertThat(converters.values().stream().anyMatch(ServiceDefinitionToZookeeperRegistration.class::isInstance)).isTrue();
    } finally {
        // shutdown spring context
        context.close();

        // shutdown zookeeper
        server.shutdown();
    }
}