org.jboss.weld.environment.se.Weld Java Examples

static Weld baseWeld() {
    Weld weld = new Weld();
    // SmallRye config
    ConfigExtension extension = new ConfigExtension();
    weld.addExtension(extension);

    weld.addBeanClass(MediatorFactory.class);
    weld.addBeanClass(MediatorManager.class);
    weld.addBeanClass(InternalChannelRegistry.class);
    weld.addBeanClass(ConfiguredChannelFactory.class);
    weld.addBeanClass(ChannelProducer.class);
    weld.addBeanClass(ExecutionHolder.class);
    weld.addBeanClass(WorkerPoolRegistry.class);
    weld.addExtension(new ReactiveMessagingExtension());

    weld.addBeanClass(SnsConnector.class);
    weld.disableDiscovery();

    return weld;
}
 

protected Weld initWithoutConnectionFactory() {
    weld = new Weld();

    // SmallRye config
    ConfigExtension extension = new ConfigExtension();
    weld.addExtension(extension);

    weld.addBeanClass(MediatorFactory.class);
    weld.addBeanClass(MediatorManager.class);
    weld.addBeanClass(InternalChannelRegistry.class);
    weld.addBeanClass(ConfiguredChannelFactory.class);
    weld.addBeanClass(ChannelProducer.class);
    weld.addBeanClass(ExecutionHolder.class);
    weld.addBeanClass(WorkerPoolRegistry.class);
    weld.addExtension(new ReactiveMessagingExtension());
    weld.addBeanClass(JmsConnector.class);
    weld.disableDiscovery();
    return weld;
}
 

@Test(expected = DeploymentException.class)
public void testConfigByCDIIncorrectBean() {
    Weld weld = new Weld();

    weld.addBeanClass(ProducingBean.class);
    weld.addBeanClass(ClientConfigurationBean.class);

    new MapBasedConfig()
            .put("mp.messaging.outgoing.sink.address", "sink")
            .put("mp.messaging.outgoing.sink.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.outgoing.sink.host", host)
            .put("mp.messaging.outgoing.sink.port", port)
            .put("mp.messaging.outgoing.sink.durable", true)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .put("mp.messaging.outgoing.sink.client-options-name", "dummyoptionsnonexistent")
            .write();

    container = weld.initialize();
}
 

@Test(expected = DeploymentException.class)
public void testConfigByCDIMissingBean() {
    Weld weld = new Weld();

    weld.addBeanClass(ConsumptionBean.class);
    weld.addBeanClass(ExecutionHolder.class);

    new MapBasedConfig()
            .put("mp.messaging.incoming.data.address", "data")
            .put("mp.messaging.incoming.data.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.incoming.data.host", host)
            .put("mp.messaging.incoming.data.port", port)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .put("mp.messaging.incoming.data.client-options-name", "myclientoptions")
            .write();

    container = weld.initialize();
}
 

@Test(expected = DeploymentException.class)
public void testConfigByCDIIncorrectBean() {
    Weld weld = new Weld();

    weld.addBeanClass(ConsumptionBean.class);
    weld.addBeanClass(ClientConfigurationBean.class);
    weld.addBeanClass(ExecutionHolder.class);

    new MapBasedConfig()
            .put("mp.messaging.incoming.data.address", "data")
            .put("mp.messaging.incoming.data.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.incoming.data.host", host)
            .put("mp.messaging.incoming.data.port", port)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .put("mp.messaging.incoming.data.client-options-name", "dummyoptionsnonexistent")
            .write();

    container = weld.initialize();
}
 

@Test(expected = DeploymentException.class)
public void testConfigGlobalOptionsByCDIIncorrectBean() {
    Weld weld = new Weld();

    weld.addBeanClass(ConsumptionBean.class);
    weld.addBeanClass(ClientConfigurationBean.class);
    weld.addBeanClass(ExecutionHolder.class);

    new MapBasedConfig()
            .put("mp.messaging.incoming.data.address", "data")
            .put("mp.messaging.incoming.data.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.incoming.data.host", host)
            .put("mp.messaging.incoming.data.port", port)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .put("amqp-client-options-name", "dummyoptionsnonexistent")
            .write();

    container = weld.initialize();
}
 

@Test
public void testABeanProducingMessagesSentToAMQPWithOutboundMetadataUsingNonAnonymousSender()
        throws InterruptedException {
    Weld weld = new Weld();

    CountDownLatch latch = new CountDownLatch(10);
    usage.consumeIntegers("sink-foo",
            v -> latch.countDown());

    weld.addBeanClass(ProducingBeanUsingOutboundMetadata.class);

    new MapBasedConfig()
            .put("mp.messaging.outgoing.sink.address", "sink-foo")
            .put("mp.messaging.outgoing.sink.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.outgoing.sink.host", host)
            .put("mp.messaging.outgoing.sink.port", port)
            .put("mp.messaging.outgoing.sink.durable", true)
            .put("mp.messaging.outgoing.sink.use-anonymous-sender", false)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .write();

    container = weld.initialize();

    assertThat(latch.await(1, TimeUnit.MINUTES)).isTrue();
}
 

@Before
public void init(TestContext context) throws InterruptedException {
    vertx = Vertx.vertx();
    Async async = context.async();
    Weld weld = WeldVerticle.createDefaultWeld().disableDiscovery().beanClasses(HelloRouteObserver.class, PaymentObserverResource.class,
            SayHelloService.class, PaymentService.class, RequestHelloService.class);
    WeldWebVerticle weldVerticle = new WeldWebVerticle(weld);
    vertx.deployVerticle(weldVerticle, deploy -> {
        if (deploy.succeeded()) {
            // Configure the router after Weld bootstrap finished
            vertx.createHttpServer().requestHandler(weldVerticle.createRouter()::accept).listen(8080, (listen) -> {
                if (listen.succeeded()) {
                    async.complete();
                } else {
                    context.fail(listen.cause());
                }
            });
        } else {
            context.fail(deploy.cause());
        }
    });
    SYNCHRONIZER.clear();
}
 

@Override
public Statement apply(final Statement base, final Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            Weld weld = WeldInitiator.this.weld;
            if (weld == null) {
                // Null in case of fromTestPackage() is used
                weld = createWeld().addPackage(false, description.getTestClass());
            }
            initWeldContainer(weld);
            try {
                base.evaluate();
            } finally {
                shutdownWeldContainer();
            }
        }
    };
}
 

@Test(expected = DeploymentException.class)
public void testConfigByCDIMissingBean() {
    Weld weld = new Weld();

    weld.addBeanClass(ProducingBean.class);

    new MapBasedConfig()
            .put("mp.messaging.outgoing.sink.address", "sink")
            .put("mp.messaging.outgoing.sink.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.outgoing.sink.host", host)
            .put("mp.messaging.outgoing.sink.port", port)
            .put("mp.messaging.outgoing.sink.durable", true)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .put("mp.messaging.outgoing.sink.client-options-name", "myclientoptions")
            .write();

    container = weld.initialize();
}
 

static Weld baseWeld() {
    Weld weld = new Weld();
    weld.addBeanClass(MediatorFactory.class);
    weld.addBeanClass(MediatorManager.class);
    weld.addBeanClass(InternalChannelRegistry.class);
    weld.addBeanClass(ConfiguredChannelFactory.class);
    weld.addBeanClass(ExecutionHolder.class);
    weld.addBeanClass(WorkerPoolRegistry.class);
    weld.addExtension(new ReactiveMessagingExtension());
    weld.addBeanClass(VertxEventBusConnector.class);

    weld.addExtension(new io.smallrye.config.inject.ConfigExtension());

    weld.disableDiscovery();
    return weld;
}
 

@Test(expected = DeploymentException.class)
@Ignore("Failing on CI - need to be investigated")
public void testConfigGlobalOptionsByCDIMissingBean() {
    Weld weld = new Weld();

    weld.addBeanClass(ProducingBean.class);

    new MapBasedConfig()
            .put("mp.messaging.outgoing.sink.address", "sink")
            .put("mp.messaging.outgoing.sink.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.outgoing.sink.host", host)
            .put("mp.messaging.outgoing.sink.port", port)
            .put("mp.messaging.outgoing.sink.durable", true)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .put("amqp-client-options-name", "dummyoptionsnonexistent")
            .write();

    container = weld.initialize();
}
 

@Test(expected = DeploymentException.class)
@Ignore("Failing on CI - to be investigated")
public void testConfigGlobalOptionsByCDIIncorrectBean() {
    Weld weld = new Weld();

    weld.addBeanClass(ProducingBean.class);
    weld.addBeanClass(ClientConfigurationBean.class);

    new MapBasedConfig()
            .put("mp.messaging.outgoing.sink.address", "sink")
            .put("mp.messaging.outgoing.sink.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.outgoing.sink.host", host)
            .put("mp.messaging.outgoing.sink.port", port)
            .put("mp.messaging.outgoing.sink.durable", true)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .put("amqp-client-options-name", "dummyoptionsnonexistent")
            .write();

    container = weld.initialize();
}
 

static Weld baseWeld(MapBasedConfig config) {
    addConfig(config);
    Weld weld = new Weld();
    weld.disableDiscovery();
    weld.addBeanClass(MediatorFactory.class);
    weld.addBeanClass(MediatorManager.class);
    weld.addBeanClass(InternalChannelRegistry.class);
    weld.addBeanClass(ConfiguredChannelFactory.class);
    weld.addBeanClass(WorkerPoolRegistry.class);
    weld.addBeanClass(ExecutionHolder.class);
    weld.addPackages(EmitterImpl.class.getPackage());
    weld.addExtension(new ReactiveMessagingExtension());
    weld.addBeanClass(MqttConnector.class);

    // Add SmallRye Config
    weld.addExtension(new io.smallrye.config.inject.ConfigExtension());

    return weld;
}
 

public static Weld baseWeld() {
    Weld weld = new Weld();

    // SmallRye config
    ConfigExtension extension = new ConfigExtension();
    weld.addExtension(extension);

    weld.addBeanClass(MediatorFactory.class);
    weld.addBeanClass(MediatorManager.class);
    weld.addBeanClass(InternalChannelRegistry.class);
    weld.addBeanClass(ConfiguredChannelFactory.class);
    weld.addBeanClass(ChannelProducer.class);
    weld.addBeanClass(ExecutionHolder.class);
    weld.addBeanClass(WorkerPoolRegistry.class);
    weld.addExtension(new ReactiveMessagingExtension());

    weld.addBeanClass(KafkaConnector.class);
    weld.disableDiscovery();
    return weld;
}
 

@Test
public void testMessageKafkaPriceConsumer() throws InterruptedException {
    MapBasedConfig config = getConsumerConfiguration();
    Weld weld = baseWeld();
    addConfig(config);
    weld.addBeanClass(KafkaPriceMessageConsumer.class);
    weld.disableDiscovery();
    container = weld.initialize();

    KafkaPriceMessageConsumer consumer = container.select(KafkaPriceMessageConsumer.class).get();

    // TODO we need some readiness support in the connector
    Thread.sleep(1000);

    KafkaUsage usage = new KafkaUsage();
    AtomicInteger count = new AtomicInteger();
    usage.produceDoubles(50, null, () -> new ProducerRecord<>("prices", count.incrementAndGet() * 1.0));

    await().until(() -> consumer.list().size() >= 50);
}
 

@Before
public void init(TestContext context) throws InterruptedException {
    vertx = Vertx.vertx();
    Async async = context.async();
    Weld weld = WeldVerticle.createDefaultWeld().disableDiscovery().beanClasses(AsyncRouteObserver.class, BlockingService.class)
            .packages(AsyncReference.class);
    WeldWebVerticle weldVerticle = new WeldWebVerticle(weld);
    vertx.deployVerticle(weldVerticle, deploy -> {
        if (deploy.succeeded()) {
            // Configure the router after Weld bootstrap finished
            vertx.createHttpServer().requestHandler(weldVerticle.createRouter()::accept).listen(8080, (listen) -> {
                if (listen.succeeded()) {
                    async.complete();
                } else {
                    context.fail(listen.cause());
                }
            });
        } else {
            context.fail(deploy.cause());
        }
    });
    SYNCHRONIZER.clear();
}
 

protected WeldContainer initWeldContainer(Weld weld) {
    // Register mock injection services if needed
    if (!resources.isEmpty()) {
        weld.addServices(new MockResourceInjectionServices(resources));
    }
    if (ejbFactory != null) {
        weld.addServices(new MockEjbInjectionServices(ejbFactory));
    }
    if (persistenceContextFactory != null || persistenceUnitFactory != null) {
        weld.addServices(new MockJpaInjectionServices(persistenceUnitFactory, persistenceContextFactory));
    }
    // Init the container
    container = weld.initialize();
    if (extension != null) {
        extension.activateContexts();
    }
    injectInstances();
    return container;
}
 

static Weld baseWeld() {
    final Weld weld = new Weld();

    weld.addExtension(new ConfigExtension());
    weld.addBeanClass(MediatorFactory.class);
    weld.addBeanClass(MediatorManager.class);
    weld.addBeanClass(InternalChannelRegistry.class);
    weld.addBeanClass(ConfiguredChannelFactory.class);
    weld.addBeanClass(ChannelProducer.class);
    weld.addBeanClass(ExecutionHolder.class);
    weld.addBeanClass(WorkerPoolRegistry.class);
    weld.addExtension(new ReactiveMessagingExtension());

    weld.addBeanClass(PubSubManager.class);
    weld.addBeanClass(PubSubConnector.class);
    weld.disableDiscovery();

    return weld;
}
 

@Test
public void testABeanProducingMessagesSentToMQTT() {
    Weld weld = baseWeld(getConfig());
    weld.addBeanClass(DynamicTopicProducingBean.class);

    final List<MqttMessage> rawMessages = new ArrayList<>(10);
    final List<String> topics = new CopyOnWriteArrayList<>();
    usage.consumeRaw("#", 10, 60, TimeUnit.SECONDS, null,
            (topic, msg) -> {
                topics.add(topic);
                rawMessages.add(msg);
            });

    container = weld.initialize();

    await().atMost(1, TimeUnit.MINUTES).until(() -> topics.size() >= 10);
    assertThat(topics.size()).isEqualTo(10);
    assertThat(rawMessages.size()).isEqualTo(10);
    MqttMessage firstMessage = rawMessages.get(0);
    assertThat(firstMessage.getQos()).isEqualTo(1);
    assertThat(firstMessage.isRetained()).isFalse();
}
 

@Test(timeout = 10000)
public void testAcknowledgmentWithQoS0AndPayloads() throws InterruptedException {
    Weld weld = baseWeld(getConfig(0));
    weld.addBeanClass(EmitterBean.class);

    CountDownLatch latch = new CountDownLatch(2);
    usage.consumeStrings("test-topic-mqtt", 2, 10, TimeUnit.SECONDS,
            null,
            v -> latch.countDown());

    container = weld.initialize();

    EmitterBean bean = container.getBeanManager().createInstance().select(EmitterBean.class).get();
    bean.sendAndAwait();
    bean.sendMessageAndAwait();
    assertThat(latch.await(1, TimeUnit.MINUTES)).isTrue();
}
 

@Test(timeout = 10000)
public void testAcknowledgmentWithQoS1AndPayloads() throws InterruptedException {
    Weld weld = baseWeld(getConfig(1));
    weld.addBeanClass(EmitterBean.class);

    CountDownLatch latch = new CountDownLatch(2);
    usage.consumeStrings("test-topic-mqtt", 2, 10, TimeUnit.SECONDS,
            null,
            v -> latch.countDown());

    container = weld.initialize();

    EmitterBean bean = container.getBeanManager().createInstance().select(EmitterBean.class).get();
    bean.sendAndAwait();
    bean.sendMessageAndAwait();
    assertThat(latch.await(1, TimeUnit.MINUTES)).isTrue();
}
 

@Test
public void testConfigGlobalOptionsByCDICorrect() throws InterruptedException {
    Weld weld = new Weld();

    CountDownLatch latch = new CountDownLatch(10);
    usage.consumeIntegers("sink",
            v -> latch.countDown());

    weld.addBeanClass(ProducingBean.class);
    weld.addBeanClass(ClientConfigurationBean.class);

    new MapBasedConfig()
            .put("mp.messaging.outgoing.sink.address", "sink")
            .put("mp.messaging.outgoing.sink.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.outgoing.sink.host", host)
            .put("mp.messaging.outgoing.sink.port", port)
            .put("mp.messaging.outgoing.sink.durable", true)
            .put("amqp-username", username)
            .put("amqp-password", password)
            .put("amqp-client-options-name", "myclientoptions")
            .write();

    container = weld.initialize();

    assertThat(latch.await(1, TimeUnit.MINUTES)).isTrue();
}
 

@Test
public void testKafkaPriceMessageProducer() {
    KafkaUsage usage = new KafkaUsage();
    List<Double> list = new CopyOnWriteArrayList<>();
    usage.consumeDoubles("prices", 50, 60, TimeUnit.SECONDS, null, (s, v) -> list.add(v));

    MapBasedConfig config = getProducerConfiguration();
    Weld weld = baseWeld();
    addConfig(config);
    weld.addBeanClass(KafkaPriceMessageProducer.class);
    weld.disableDiscovery();
    container = weld.initialize();

    await().until(() -> list.size() >= 50);
}
 

private MyReceiverBean deploy() {
    Weld weld = new Weld();
    weld.addBeanClass(MyReceiverBean.class);

    container = weld.initialize();
    await().until(() -> container.select(MediatorManager.class).get().isInitialized());
    return container.getBeanManager().createInstance().select(MyReceiverBean.class).get();
}
 

@Test
public void testKafkaPriceProducer() {
    KafkaUsage usage = new KafkaUsage();
    List<Double> list = new CopyOnWriteArrayList<>();
    usage.consumeDoubles("prices", 50, 60, TimeUnit.SECONDS, null, (s, v) -> list.add(v));

    MapBasedConfig config = getProducerConfiguration();
    Weld weld = baseWeld();
    addConfig(config);
    weld.addBeanClass(KafkaPriceProducer.class);
    weld.disableDiscovery();
    container = weld.initialize();

    await().until(() -> list.size() >= 50);
}
 

public RequestHandler() {

		Weld weld = new Weld();
		weld.initialize();

		// configure the application with the resource
		ResourceConfig resourceConfig = new ResourceConfig()
				.register(GatewayFeature.class)
				.packages("com.jrestless.aws.examples");
		init(resourceConfig);
		start();
	}
 

@Test(expected = UnsatisfiedResolutionException.class)
public void bootWeldSeContainer() {
    Extension testExtension = ContainerLifecycleObserver.extensionBuilder()
        .add(afterBeanDiscovery((e) -> System.out.println("Bean discovery completed!")))
        .add(processAnnotatedType().notify((e) -> {
            if (e.getAnnotatedType().getJavaClass().getName().startsWith("com.hantsylab")) {
                e.veto();
            }
        })).build();
    try (WeldContainer container = new Weld().addExtension(testExtension).initialize()) {
        Greeter greeter = container.select(Greeter.class).get();
        //assertTrue(greeter == null);
    }

}
 

@Test
public void test() {
    Weld weld = new Weld();

    weld.addBeanClass(MyProducer.class);
    weld.addBeanClass(MyConsumer.class);

    new MapBasedConfig()
            .put("mp.messaging.outgoing.people-out.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.outgoing.people-out.address", "people")
            .put("mp.messaging.outgoing.people-out.link-name", "people")
            .put("mp.messaging.outgoing.people-out.host", host)
            .put("mp.messaging.outgoing.people-out.port", port)
            .put("mp.messaging.outgoing.people-out.durable", true)
            .put("amqp-username", username)
            .put("amqp-password", password)

            .put("mp.messaging.incoming.people-in.connector", AmqpConnector.CONNECTOR_NAME)
            .put("mp.messaging.incoming.people-in.address", "people")
            .put("mp.messaging.incoming.people-in.link-name", "people")
            .put("mp.messaging.incoming.people-in.host", host)
            .put("mp.messaging.incoming.people-in.port", port)
            .put("mp.messaging.incoming.people-in.durable", true)

            .write();

    container = weld.initialize();
    AmqpConnector connector = container.getBeanManager().createInstance().select(AmqpConnector.class,
            ConnectorLiteral.of(AmqpConnector.CONNECTOR_NAME)).get();
    await().until(() -> connector.isReady("people-in"));

    MyProducer producer = container.getBeanManager().createInstance().select(MyProducer.class).get();
    producer.run();

    MyConsumer consumer = container.getBeanManager().createInstance().select(MyConsumer.class).get();
    await()
            .atMost(1, TimeUnit.MINUTES)
            .until(() -> consumer.list().size() == 3);
    assertThat(consumer.list()).containsExactly("Luke", "Leia", "Han");
}
 

@Test
public void testABeanProducingMessagesSentToEventBus() {
    Weld weld = baseWeld();
    weld.addBeanClass(ProducingBean.class);
    weld.addBeanClass(VertxProducer.class);
    addConfig(getConfig());
    container = weld.initialize();
    ProducingBean bean = container.getBeanManager().createInstance().select(ProducingBean.class).get();

    await().until(() -> bean.messages().size() == 10);
    assertThat(bean.messages().size()).isEqualTo(10);
}