javax.enterprise.event.TransactionPhase Java Examples

ObserverInfo(BeanDeployment beanDeployment, DotName beanClass, BeanInfo declaringBean, MethodInfo observerMethod,
        Injection injection,
        MethodParameterInfo eventParameter,
        boolean isAsync, int priority, Reception reception, TransactionPhase transactionPhase,
        Type observedType, Set<AnnotationInstance> qualifiers, Consumer<MethodCreator> notify) {
    this.beanDeployment = beanDeployment;
    this.beanClass = beanClass;
    this.declaringBean = declaringBean;
    this.observerMethod = observerMethod;
    this.injection = injection;
    this.eventParameter = eventParameter;
    this.eventMetadataParameterPosition = initEventMetadataParam(observerMethod);
    this.isAsync = isAsync;
    this.priority = priority;
    this.reception = reception;
    this.transactionPhase = transactionPhase;
    this.observedType = observedType;
    this.qualifiers = qualifiers;
    this.notify = notify;
}
 

/**
 * Test method for {@link EventPublisher#addEvent(EventKey, PublisherConfiguration)},
 * {@link EventPublisher#publishEvent(Object, TransactionPhase)} and
 * {@link EventPublisher#cleanUp()}.
 * 
 * @throws TimeoutException
 * @throws IOException
 */
@Test
public void testPublishEvent_failing() throws IOException, TimeoutException {
  EventKey<TestEvent> key = EventKey.of(TestEvent.class, TransactionPhase.AFTER_FAILURE);

  when(connectionRepository.getConnection(config)).thenReturn(connection);
  when(connection.createChannel()).thenReturn(channel);
  doThrow(IOException.class).when(channel).basicPublish(eq("exchange"), eq("routingKey"), any(),
      any());

  publisher.addEvent(key, new PublisherConfiguration(config, "exchange", routingKeyFunction,
      basicProperties, encoder, errorHandler, declarations));
  publisher.publishEvent(new TestEvent(), TransactionPhase.AFTER_FAILURE);
  publisher.cleanUp();

  verify(channel, times(3)).close();
}
 

/**
 * Test method for {@link EventKey#equals(Object)}.
 */
@Test
void testEqualsObject() {
  assertNotEquals(eventKey, null);
  assertNotEquals(eventKey, new Object());
  assertNotEquals(eventKey, EventKey.of(Object.class, TransactionPhase.IN_PROGRESS));
  assertNotEquals(eventKey, EventKey.of(TestEvent.class, TransactionPhase.AFTER_COMPLETION));

  assertEquals(eventKey, eventKey);

  EventKey<TestEvent> eventKey1 = EventKey.of(TestEvent.class, TransactionPhase.IN_PROGRESS);
  assertEquals(eventKey, eventKey1);
  assertEquals(eventKey1, eventKey);

  EventKey<TestEvent> eventKey2 = EventKey.of(TestEvent.class, TransactionPhase.IN_PROGRESS);
  assertEquals(eventKey, eventKey2);

  assertEquals(eventKey1, eventKey2);
  assertEquals(eventKey1.hashCode(), eventKey2.hashCode());
}
 

@Test
public void saveAuditLogEntries_hasObserverMethodAfterSuccessAnnotation() {
    // given
    AuditLogEntries auditLogEntries = new AuditLogEntries(
            new ArrayList<AuditLogEntry>());
    List<ObserverMethod> observerMethods = contextManager
            .findObserverMethods(auditLogEntries);
    Method method = observerMethods.get(0).getMethod();

    // when
    Observes observes = (Observes) contextManager.searchAnnotation(method,
            Observes.class);

    // then
    assertEquals(TransactionPhase.AFTER_SUCCESS, observes.during());
}
 

@Override
public void registerTransactionSynchronization(final TransactionPhase phase, final ObserverMethod<? super Object> observer, final Object event) throws Exception {
    Set<Annotation> qualifiers = observer.getObservedQualifiers();
    if (qualifiers == null) {
        qualifiers = Collections.emptySet();
    }

    TransactionalEventNotifier.registerTransactionSynchronization(phase, observer, event,
        new EventMetadataImpl(observer.getObservedType(), null, null,
            qualifiers.toArray(new Annotation[qualifiers.size()]), webBeansContext));
}
 

@Test
public void testOnEventAfterSuccess() throws IOException, TimeoutException {
  EventKey<TestEvent> key = EventKey.of(TestEvent.class, TransactionPhase.AFTER_SUCCESS);

  when(connectionRepository.getConnection(config)).thenReturn(connection);
  when(connection.createChannel()).thenReturn(channel);

  publisher.addEvent(key, new PublisherConfiguration(config, "exchange", routingKeyFunction,
      basicProperties, encoder, errorHandler, declarations));
  publisher.onEventAfterSuccess(new TestEvent());
  publisher.cleanUp();

  verify(channel).basicPublish(eq("exchange"), eq("routingKey"), any(), any());
  verify(channel).close();
}
 

@Test
public void testOnEventAfterFailure() throws IOException, TimeoutException {
  EventKey<TestEvent> key = EventKey.of(TestEvent.class, TransactionPhase.AFTER_FAILURE);

  when(connectionRepository.getConnection(config)).thenReturn(connection);
  when(connection.createChannel()).thenReturn(channel);

  publisher.addEvent(key, new PublisherConfiguration(config, "exchange", routingKeyFunction,
      basicProperties, encoder, errorHandler, declarations));
  publisher.onEventAfterFailure(new TestEvent());
  publisher.cleanUp();

  verify(channel).basicPublish(eq("exchange"), eq("routingKey"), any(), any());
  verify(channel).close();
}
 

@Test
public void testOnEventAfterCompletion() throws IOException, TimeoutException {
  EventKey<TestEvent> key = EventKey.of(TestEvent.class, TransactionPhase.AFTER_COMPLETION);

  when(connectionRepository.getConnection(config)).thenReturn(connection);
  when(connection.createChannel()).thenReturn(channel);

  publisher.addEvent(key, new PublisherConfiguration(config, "exchange", routingKeyFunction,
      basicProperties, encoder, errorHandler, declarations));
  publisher.onEventAfterCompletion(new TestEvent());
  publisher.cleanUp();

  verify(channel).basicPublish(eq("exchange"), eq("routingKey"), any(), any());
  verify(channel).close();
}
 

@Test
public void testOnEventInBeforeCompletion() throws IOException, TimeoutException {
  EventKey<TestEvent> key = EventKey.of(TestEvent.class, TransactionPhase.BEFORE_COMPLETION);

  when(connectionRepository.getConnection(config)).thenReturn(connection);
  when(connection.createChannel()).thenReturn(channel);

  publisher.addEvent(key, new PublisherConfiguration(config, "exchange", routingKeyFunction,
      basicProperties, encoder, errorHandler, declarations));
  publisher.onEventBeforeCompletion(new TestEvent());
  publisher.cleanUp();

  verify(channel).basicPublish(eq("exchange"), eq("routingKey"), any(), any());
  verify(channel).close();
}
 

@Test
public void testOnEventInProgress() throws IOException, TimeoutException {
  EventKey<TestEvent> key = EventKey.of(TestEvent.class, TransactionPhase.IN_PROGRESS);

  when(connectionRepository.getConnection(config)).thenReturn(connection);
  when(connection.createChannel()).thenReturn(channel);

  publisher.addEvent(key, new PublisherConfiguration(config, "exchange", routingKeyFunction,
      basicProperties, encoder, errorHandler, declarations));
  publisher.onEventInProgress(new TestEvent());
  publisher.cleanUp();

  verify(channel).basicPublish(eq("exchange"), eq("routingKey"), any(), any());
  verify(channel).close();
}
 

/**
 * Test method for {@link EventPublisher#addEvent(EventKey, PublisherConfiguration)},
 * {@link EventPublisher#publishEvent(Object, TransactionPhase)} and
 * {@link EventPublisher#cleanUp()}.
 * 
 * @throws TimeoutException
 * @throws IOException
 */
@Test
public void testPublishEvent() throws IOException, TimeoutException {
  EventKey<TestEvent> key = EventKey.of(TestEvent.class, TransactionPhase.AFTER_SUCCESS);
  when(connectionRepository.getConnection(config)).thenReturn(connection);
  when(connection.createChannel()).thenReturn(channel);

  publisher.addEvent(key, new PublisherConfiguration(config, "exchange", routingKeyFunction,
      basicProperties, encoder, errorHandler, declarations));
  publisher.publishEvent(new TestEvent(), TransactionPhase.AFTER_SUCCESS);
  publisher.cleanUp();

  verify(channel).basicPublish(eq("exchange"), eq("routingKey"), any(), any());
  verify(channel).close();
}
 

void publishEvent(Object event, TransactionPhase transactionPhase) {
  @SuppressWarnings("unchecked")
  EventKey<Object> eventKey =  (EventKey<Object>) EventKey.of(event.getClass(), transactionPhase);
  @SuppressWarnings("unchecked")
  PublisherConfiguration<Object> configuration = (PublisherConfiguration<Object>) publisherConfigurations.get(eventKey);
  if (configuration == null) {
    LOGGER.trace("No publisher configured for event {}", event);
  } else {
    doPublish(event, providePublisher(eventKey, transactionPhase), configuration);
  }
}
 

ExchangeBinding(Class<T> eventType, String exchange) {
  this.eventType = eventType;
  this.exchange = exchange;
  this.headers = new HashMap<>();
  this.encoder = new JsonEncoder<>();
  routingKeyFunction = e -> "";
  transactionPhase = TransactionPhase.IN_PROGRESS;
  errorHandler = nop();
  basicPropertiesBuilder = MessageProperties.BASIC.builder().headers(headers);
  LOGGER.info("Binding created between exchange {} and event type {}", exchange,
      eventType.getSimpleName());
}
 

static TransactionPhase initTransactionPhase(boolean isAsync, BeanDeployment beanDeployment, MethodInfo observerMethod) {
    AnnotationInstance observesAnnotation = isAsync
            ? beanDeployment.getAnnotation(observerMethod, DotNames.OBSERVES_ASYNC)
            : beanDeployment.getAnnotation(observerMethod, DotNames.OBSERVES);
    AnnotationValue duringValue = observesAnnotation.value("during");
    if (duringValue == null) {
        return TransactionPhase.IN_PROGRESS;
    }
    return TransactionPhase.valueOf(duringValue.asEnum());
}
 

public ObserverTransformationContext(BuildContext buildContext, AnnotationTarget target,
        Type observedType, Set<AnnotationInstance> qualifiers, Reception reception, TransactionPhase transactionPhase,
        Integer priority, boolean async) {
    super(buildContext, target, qualifiers);
    this.observedType = observedType;
    this.reception = reception;
    this.transactionPhase = transactionPhase;
    this.priority = priority;
    this.async = async;
}
 

public ObserverConfigurator(Consumer<ObserverConfigurator> consumer) {
    this.consumer = consumer;
    this.observedQualifiers = new HashSet<>();
    this.priority = ObserverMethod.DEFAULT_PRIORITY;
    this.isAsync = false;
    this.transactionPhase = TransactionPhase.IN_PROGRESS;
}
 

public static Status valueOf(TransactionPhase transactionPhase) {
    if (transactionPhase == TransactionPhase.BEFORE_COMPLETION
            || transactionPhase == TransactionPhase.AFTER_COMPLETION) {
        return Status.ALL;
    }
    if (transactionPhase == TransactionPhase.AFTER_SUCCESS) {
        return Status.SUCCESS;
    }
    if (transactionPhase == TransactionPhase.AFTER_FAILURE) {
        return Status.FAILURE;
    }
    throw new IllegalArgumentException("Unknown transaction phase " + transactionPhase);
}
 

DeferredEventNotification(ObserverMethod<? super T> observerMethod, EventContext eventContext, Status status) {
    this.observerMethod = observerMethod;
    this.isBeforeCompletion = observerMethod.getTransactionPhase().equals(TransactionPhase.BEFORE_COMPLETION);
    this.eventContext = eventContext;
    this.status = status;
}
 

public TransactionPhase getTransactionPhase() {
    return transactionPhase;
}
 

public void observesShort(@Observes(during=TransactionPhase.IN_PROGRESS) Short event) {
    sb.append(event);
}
 

public void observeInteger(@Observes(during=TransactionPhase.BEFORE_COMPLETION) Integer event) {
    sb.append(event);
}
 

public void observesLong(@Observes(during=TransactionPhase.AFTER_COMPLETION) Long event) {
    sb.append(event);
}
 

@Test
void inPhase() {
  assertEquals(TransactionPhase.IN_PROGRESS, binding.getTransactionPhase());
  assertSame(binding, binding.inPhase(TransactionPhase.AFTER_COMPLETION));
  assertEquals(TransactionPhase.AFTER_COMPLETION, binding.getTransactionPhase());
}
 

@Override
public TransactionPhase getTransactionPhase() {
    return transactionPhase;
}
 

protected void implementGetTransactionPhase(ClassCreator observerCreator, ObserverInfo observer) {
    MethodCreator getTransactionPhase = observerCreator.getMethodCreator("getTransactionPhase", TransactionPhase.class)
            .setModifiers(ACC_PUBLIC);
    getTransactionPhase.returnValue(getTransactionPhase.load(observer.getTransactionPhase()));
}
 

private boolean isTxObserver(ObserverMethod<?> observer) {
    return !observer.getTransactionPhase().equals(TransactionPhase.IN_PROGRESS);
}
 

/**
 * Test method for {@link EventPublisher#publishEvent(Object, TransactionPhase)}.
 */
@Test
public void testPublishEvent_no_configuration() {
  publisher.publishEvent(new TestEvent(), TransactionPhase.AFTER_COMPLETION);
}
 

private boolean isNotAfterSuccess(ObserverMethod<?> observer) {
    return !observer.getTransactionPhase().equals(TransactionPhase.AFTER_SUCCESS);
}
 

@BeforeEach
void prepare() {
  eventKey = EventKey.of(TestEvent.class, TransactionPhase.IN_PROGRESS);
}
 

public void saveAuditLogEntries(
        @Observes(during = TransactionPhase.AFTER_SUCCESS) AuditLogEntries logData) {
    dao.saveAuditLog(logData.getAuditLogEntries());
}