ARQ-1743 Configuration and callable creation are merged together

There are only two events now: BeforeDronePrepared AfterDronePrepared instead of the four: BeforeDroneCallableCreated BeforeDroneConfigured AfterDroneConfigured AfterDroneCallableCreated
arquillian · Dec 4, 2015 · 543eb15 · 543eb15
1 parent 93166c8
commit 543eb15
Show file tree

Hide file tree

Showing 7 changed files with 111 additions and 189 deletions.
diff --git a/drone-impl/src/main/java/org/jboss/arquillian/drone/impl/DroneConfigurator.java b/drone-impl/src/main/java/org/jboss/arquillian/drone/impl/DroneConfigurator.java
@@ -1,6 +1,6 @@
-/*
+/**
  * JBoss, Home of Professional Open Source
- * Copyright 2011, Red Hat Middleware LLC, and individual contributors
+ * Copyright 2015, Red Hat Middleware LLC, and individual contributors
  * by the @authors tag. See the copyright.txt in the distribution for a
  * full listing of individual contributors.
  *
@@ -16,29 +16,26 @@
  */
 package org.jboss.arquillian.drone.impl;
 
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
 import org.jboss.arquillian.config.descriptor.api.ArquillianDescriptor;
 import org.jboss.arquillian.core.api.Event;
 import org.jboss.arquillian.core.api.Instance;
 import org.jboss.arquillian.core.api.annotation.Inject;
 import org.jboss.arquillian.core.api.annotation.Observes;
-import org.jboss.arquillian.drone.spi.CachingCallable;
 import org.jboss.arquillian.drone.spi.Configurator;
 import org.jboss.arquillian.drone.spi.DroneConfiguration;
 import org.jboss.arquillian.drone.spi.DroneContext;
 import org.jboss.arquillian.drone.spi.DronePoint;
 import org.jboss.arquillian.drone.spi.DroneRegistry;
 import org.jboss.arquillian.drone.spi.Instantiator;
 import org.jboss.arquillian.drone.spi.command.PrepareDrone;
-import org.jboss.arquillian.drone.spi.event.AfterDroneCallableCreated;
-import org.jboss.arquillian.drone.spi.event.AfterDroneConfigured;
-import org.jboss.arquillian.drone.spi.event.BeforeDroneCallableCreated;
-import org.jboss.arquillian.drone.spi.event.BeforeDroneConfigured;
+import org.jboss.arquillian.drone.spi.event.AfterDronePrepared;
+import org.jboss.arquillian.drone.spi.event.BeforeDronePrepared;
 import org.jboss.arquillian.test.spi.event.suite.Before;
 import org.jboss.arquillian.test.spi.event.suite.BeforeClass;
 
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
 /**
  * Creator of Drone configurations. Drone configuration is created either before class or before method,
  * depending on the scope
@@ -57,9 +54,10 @@
  * <p>
  * Fires:
  * </p>
- * {@link BeforeDroneConfigured} {@link AfterDroneConfigured}
+ * {@link BeforeDronePrepared} {@link AfterDronePrepared}
  *
  * @author <a href="mailto:kpiwko@redhat.com">Karel Piwko</a>
+ * @author <a href="mailto:mjobanek@redhat.com">Matous Jobanek</a>
  */
 public class DroneConfigurator {
     private static Logger logger = Logger.getLogger(DroneConfigurator.class.getName());
@@ -71,82 +69,78 @@ public class DroneConfigurator {
     private Instance<ArquillianDescriptor> arquillianDescriptor;
 
     @Inject
-    private Event<BeforeDroneConfigured> beforeDroneConfiguredEvent;
-
-    @Inject
-    private Event<AfterDroneConfigured> afterDroneConfiguredEvent;
+    private Event<BeforeDronePrepared> beforeDronePreparedEvent;
 
     @Inject
-    private Event<BeforeDroneCallableCreated> beforeDroneCallableCreatedEvent;
-
-    @Inject
-    private Event<AfterDroneCallableCreated> afterDroneCallableCreatedEvent;
+    private Event<AfterDronePrepared> afterDronePreparedEvent;
 
     public void prepareDrone(@Observes PrepareDrone command, DroneRegistry registry) {
         DronePoint<?> dronePoint = command.getDronePoint();
-
-        configureDrone(registry, dronePoint);
-
-        createDroneCallable(registry, dronePoint);
+        prepare(dronePoint, registry);
     }
 
-    private <DRONE> void configureDrone(DroneRegistry registry, DronePoint<DRONE> dronePoint) {
-        ArquillianDescriptor descriptor = arquillianDescriptor.get();
-        DroneContext context = droneContext.get();
-        Validate.stateNotNull(descriptor, "ArquillianDescriptor should not be null");
-        Validate.stateNotNull(context, "DroneContext should be available while working with method scoped instances");
+    private <DRONE> void prepare(DronePoint<DRONE> dronePoint, DroneRegistry registry) {
+        Validate.stateNotNull(droneContext.get(),
+                              "DroneContext should be available while working with method scoped instances");
 
-        if (context.get(dronePoint).hasConfiguration()) {
-            logger.log(Level.WARNING, "Could not configure drone for injection point {0}, " +
-                    "because it was already configured!", dronePoint);
-            return;
+        Configurator<DRONE, ?> droneConfigurator = getDroneConfigurator(registry, dronePoint);
+        Instantiator callableInstantiator = getCallableInstantiator(registry, dronePoint);
+
+        if (droneConfigurator != null || callableInstantiator != null) {
+            beforeDronePreparedEvent.fire(new BeforeDronePrepared(droneConfigurator, callableInstantiator, dronePoint));
+            performDronePreparation(dronePoint, droneConfigurator, callableInstantiator);
+            afterDronePreparedEvent.fire(new AfterDronePrepared(dronePoint));
         }
+    }
 
-        Configurator<DRONE, ?> configurator = registry.getEntryFor(dronePoint.getDroneType(), Configurator.class);
+    private <DRONE> void performDronePreparation(final DronePoint<DRONE> dronePoint,
+        Configurator<DRONE, ?> droneConfigurator, final Instantiator instantiator) {
 
-        beforeDroneConfiguredEvent.fire(new BeforeDroneConfigured(configurator, dronePoint));
+        final DroneContext context = droneContext.get();
+        final ArquillianDescriptor descriptor = arquillianDescriptor.get();
+        Validate.stateNotNull(descriptor, "ArquillianDescriptor should not be null");
 
         // If nobody else provided the configuration, we have to do it
-        if (!context.get(dronePoint).hasConfiguration()) {
-            DroneConfiguration configuration = configurator.createConfiguration(descriptor, dronePoint);
+        DroneConfiguration configuration = droneConfigurator.createConfiguration(descriptor, dronePoint);
+        context.get(dronePoint).setConfiguration(configuration);
 
-            context.get(dronePoint).setConfiguration(configuration);
-        }
+        // create future instance
+        CachingCallableImpl<DRONE> futureDrone = new CachingCallableImpl<DRONE>() {
+            @Override
+            protected DRONE createInstance() throws Exception {
+                DroneConfiguration<?> configuration = context
+                    .get(dronePoint)
+                    .getConfigurationAs(DroneConfiguration.class);
+                return (DRONE) instantiator.createInstance(configuration);
+            }
+        };
 
-        afterDroneConfiguredEvent.fire(new AfterDroneConfigured(dronePoint));
+        context.get(dronePoint).setFutureInstance(futureDrone);
     }
 
-    private <DRONE> void createDroneCallable(DroneRegistry registry, final DronePoint<DRONE> dronePoint) {
-        final DroneContext context = droneContext.get();
+    private <DRONE> Configurator<DRONE, ?> getDroneConfigurator(DroneRegistry registry, DronePoint<DRONE> dronePoint) {
+        if (droneContext.get().get(dronePoint).hasConfiguration()) {
+            logger.log(Level.WARNING, "Could not configure drone for injection point {0}, " +
+                "because it was already configured!", dronePoint);
+            return null;
+        }
+        return registry.getEntryFor(dronePoint.getDroneType(), Configurator.class);
+    }
 
-        if (context.get(dronePoint).hasFutureInstance()) {
+    private <DRONE> Instantiator getCallableInstantiator(DroneRegistry registry, final DronePoint<DRONE> dronePoint) {
+        if (droneContext.get().get(dronePoint).hasFutureInstance()) {
             logger.log(Level.WARNING, "Could not create drone callable for injection point {0}, " +
                     "because it was already created!", dronePoint);
-            return;
+            return null;
         }
 
         final Instantiator instantiator = registry.getEntryFor(dronePoint.getDroneType(), Instantiator.class);
         if (logger.isLoggable(Level.FINE)) {
             logger.fine("Using instantiator defined in class: " + instantiator.getClass().getName() + ", " +
-                    "with precedence " + instantiator.getPrecedence());
-        }
-
-        beforeDroneCallableCreatedEvent.fire(new BeforeDroneCallableCreated(instantiator, dronePoint));
+                            "with precedence " + instantiator.getPrecedence());
 
-        // create future instance
-        CachingCallable<DRONE> futureDrone = new CachingCallableImpl<DRONE>() {
-            @Override
-            protected DRONE createInstance() throws Exception {
-                DroneConfiguration<?> configuration = context
-                        .get(dronePoint)
-                        .getConfigurationAs(DroneConfiguration.class);
-                return (DRONE) instantiator.createInstance(configuration);
-            }
-        };
-
-        context.get(dronePoint).setFutureInstance(futureDrone);
-
-        afterDroneCallableCreatedEvent.fire(new AfterDroneCallableCreated(dronePoint));
+        }
+        return instantiator;
     }
 
 }
diff --git a/drone-impl/src/test/java/org/jboss/arquillian/drone/impl/DestroyerTestCase.java b/drone-impl/src/test/java/org/jboss/arquillian/drone/impl/DestroyerTestCase.java
@@ -36,14 +36,12 @@
 import org.jboss.arquillian.drone.spi.DroneContext;
 import org.jboss.arquillian.drone.spi.DroneRegistry;
 import org.jboss.arquillian.drone.spi.Instantiator;
-import org.jboss.arquillian.drone.spi.event.AfterDroneCallableCreated;
-import org.jboss.arquillian.drone.spi.event.AfterDroneConfigured;
 import org.jboss.arquillian.drone.spi.event.AfterDroneDestroyed;
 import org.jboss.arquillian.drone.spi.event.AfterDroneInstantiated;
-import org.jboss.arquillian.drone.spi.event.BeforeDroneCallableCreated;
-import org.jboss.arquillian.drone.spi.event.BeforeDroneConfigured;
+import org.jboss.arquillian.drone.spi.event.AfterDronePrepared;
 import org.jboss.arquillian.drone.spi.event.BeforeDroneDestroyed;
 import org.jboss.arquillian.drone.spi.event.BeforeDroneInstantiated;
+import org.jboss.arquillian.drone.spi.event.BeforeDronePrepared;
 import org.jboss.arquillian.test.spi.TestEnricher;
 import org.jboss.arquillian.test.spi.context.ClassContext;
 import org.jboss.arquillian.test.spi.context.SuiteContext;
@@ -122,18 +120,18 @@ public void mockDestructorWontTriggerAndWontFail() throws Exception {
         Assert.assertTrue("Configurator is of mock type",
                 registry.getEntryFor(MockDrone.class, Configurator.class) instanceof MockDroneFactory);
 
-        assertEventFired(BeforeDroneCallableCreated.class, 0);
-        assertEventFired(AfterDroneCallableCreated.class, 0);
+        assertEventFired(BeforeDronePrepared.class, 0);
+        assertEventFired(AfterDronePrepared.class, 0);
 
         fire(new BeforeClass(DummyClass.class));
 
-        assertEventFired(BeforeDroneCallableCreated.class, 2);
-        assertEventFired(AfterDroneCallableCreated.class, 2);
+        assertEventFired(BeforeDronePrepared.class, 2);
+        assertEventFired(AfterDronePrepared.class, 2);
 
         fire(new Before(instance, testMethod));
 
-        assertEventFired(BeforeDroneCallableCreated.class, 2);
-        assertEventFired(AfterDroneCallableCreated.class, 2);
+        assertEventFired(BeforeDronePrepared.class, 2);
+        assertEventFired(AfterDronePrepared.class, 2);
 
         assertEventFired(BeforeDroneInstantiated.class, 0);
         assertEventFired(AfterDroneInstantiated.class, 0);
@@ -168,24 +166,18 @@ public void mockDestructorWillTriggerTwice() throws Exception {
         Assert.assertTrue(registry.getEntryFor(MockDrone.class, Instantiator.class) instanceof MockDroneFactory);
         Assert.assertTrue(registry.getEntryFor(MockDrone.class, Destructor.class) instanceof MockDroneFactory);
 
-        assertEventFired(BeforeDroneConfigured.class, 0);
-        assertEventFired(AfterDroneConfigured.class, 0);
-        assertEventFired(BeforeDroneCallableCreated.class, 0);
-        assertEventFired(AfterDroneCallableCreated.class, 0);
+        assertEventFired(BeforeDronePrepared.class, 0);
+        assertEventFired(AfterDronePrepared.class, 0);
 
         fire(new BeforeClass(DummyClass.class));
 
-        assertEventFired(BeforeDroneConfigured.class, 2);
-        assertEventFired(AfterDroneConfigured.class, 2);
-        assertEventFired(BeforeDroneCallableCreated.class, 2);
-        assertEventFired(AfterDroneCallableCreated.class, 2);
+        assertEventFired(BeforeDronePrepared.class, 2);
+        assertEventFired(AfterDronePrepared.class, 2);
 
         fire(new Before(instance, testDummyMethod));
 
-        assertEventFired(BeforeDroneConfigured.class, 2);
-        assertEventFired(AfterDroneConfigured.class, 2);
-        assertEventFired(BeforeDroneCallableCreated.class, 2);
-        assertEventFired(AfterDroneCallableCreated.class, 2);
+        assertEventFired(BeforeDronePrepared.class, 2);
+        assertEventFired(AfterDronePrepared.class, 2);
 
         assertEventFired(BeforeDroneInstantiated.class, 0);
         assertEventFired(AfterDroneInstantiated.class, 0);
@@ -210,10 +202,8 @@ public void mockDestructorWillTriggerTwice() throws Exception {
 
         fire(new Before(instance, testDummyMethodWithParameters));
 
-        assertEventFired(BeforeDroneConfigured.class, 3);
-        assertEventFired(AfterDroneConfigured.class, 3);
-        assertEventFired(BeforeDroneCallableCreated.class, 3);
-        assertEventFired(AfterDroneCallableCreated.class, 3);
+        assertEventFired(BeforeDronePrepared.class, 3);
+        assertEventFired(AfterDronePrepared.class, 3);
 
         assertEventFired(BeforeDroneInstantiated.class, 2);
         assertEventFired(AfterDroneInstantiated.class, 2);

diff --git a/drone-impl/src/test/java/org/jboss/arquillian/drone/impl/InjectionPointsTest.java b/drone-impl/src/test/java/org/jboss/arquillian/drone/impl/InjectionPointsTest.java
@@ -37,14 +37,12 @@
 import org.jboss.arquillian.drone.spi.DroneRegistry;
 import org.jboss.arquillian.drone.spi.Instantiator;
 import org.jboss.arquillian.drone.spi.command.PrepareDrone;
-import org.jboss.arquillian.drone.spi.event.AfterDroneCallableCreated;
-import org.jboss.arquillian.drone.spi.event.AfterDroneConfigured;
 import org.jboss.arquillian.drone.spi.event.AfterDroneDestroyed;
 import org.jboss.arquillian.drone.spi.event.AfterDroneInstantiated;
-import org.jboss.arquillian.drone.spi.event.BeforeDroneCallableCreated;
-import org.jboss.arquillian.drone.spi.event.BeforeDroneConfigured;
+import org.jboss.arquillian.drone.spi.event.AfterDronePrepared;
 import org.jboss.arquillian.drone.spi.event.BeforeDroneDestroyed;
 import org.jboss.arquillian.drone.spi.event.BeforeDroneInstantiated;
+import org.jboss.arquillian.drone.spi.event.BeforeDronePrepared;
 import org.jboss.arquillian.test.spi.TestEnricher;
 import org.jboss.arquillian.test.spi.context.ClassContext;
 import org.jboss.arquillian.test.spi.context.SuiteContext;
@@ -144,18 +142,14 @@ private void runCustomAnnotationHasNoEffectTest(Class<?> testClass, String befor
         Assert.assertTrue(registry.getEntryFor(MockDrone.class, Destructor.class) instanceof MockDroneFactory);
 
         assertEventFired(PrepareDrone.class, 0);
-        assertEventFired(BeforeDroneConfigured.class, 0);
-        assertEventFired(AfterDroneConfigured.class, 0);
-        assertEventFired(BeforeDroneCallableCreated.class, 0);
-        assertEventFired(AfterDroneCallableCreated.class, 0);
+        assertEventFired(BeforeDronePrepared.class, 0);
+        assertEventFired(AfterDronePrepared.class, 0);
 
         fire(new BeforeClass(testClass));
 
         assertEventFired(PrepareDrone.class, 2);
-        assertEventFired(BeforeDroneConfigured.class, 2);
-        assertEventFired(AfterDroneConfigured.class, 2);
-        assertEventFired(BeforeDroneCallableCreated.class, 2);
-        assertEventFired(AfterDroneCallableCreated.class, 2);
+        assertEventFired(BeforeDronePrepared.class, 2);
+        assertEventFired(AfterDronePrepared.class, 2);
 
         if (createdInBeforeClass) {
             assertEventFired(BeforeDroneInstantiated.class, 2);
@@ -168,11 +162,9 @@ private void runCustomAnnotationHasNoEffectTest(Class<?> testClass, String befor
         fire(new Before(instance, testMethod));
 
         assertEventFired(PrepareDrone.class, 2);
-        assertEventFired(BeforeDroneConfigured.class, 2);
-        assertEventFired(AfterDroneConfigured.class, 2);
-        assertEventFired(BeforeDroneCallableCreated.class, 2);
-        assertEventFired(AfterDroneCallableCreated.class, 2);
-
+        assertEventFired(BeforeDronePrepared.class, 2);
+        assertEventFired(AfterDronePrepared.class, 2);
+
         if (!createdInBeforeClass) {
             // was not instantiated yet
             assertEventFired(BeforeDroneInstantiated.class, 0);

diff --git a/drone-spi/src/main/java/org/jboss/arquillian/drone/spi/event/AfterDroneConfigured.java b/drone-spi/src/main/java/org/jboss/arquillian/drone/spi/event/AfterDroneConfigured.java
diff --git a/.../spi/event/AfterDroneCallableCreated.java → ...n/drone/spi/event/AfterDronePrepared.java b/.../spi/event/AfterDroneCallableCreated.java → ...n/drone/spi/event/AfterDronePrepared.java
@@ -1,6 +1,6 @@
-/*
+/**
  * JBoss, Home of Professional Open Source
- * Copyright 2013, Red Hat Middleware LLC, and individual contributors
+ * Copyright 2015, Red Hat Middleware LLC, and individual contributors
  * by the @authors tag. See the copyright.txt in the distribution for a
  * full listing of individual contributors.
  *
@@ -20,13 +20,16 @@
 import org.jboss.arquillian.drone.spi.DronePoint;
 
 /**
- * This event is fired after Drone instance callable is created and stored in {@link DroneContext}.
+ * This event is called after Drone preparation is finished. By observing this event, you can modify Drone configuration
+ * after it's creation. Drone instance callable is created and stored in {@link DroneContext}
  *
+ * @author <a href="mailto:mjobanek@redhat.com">Matous Jobanek</a>
  * @author <a href="mailto:kpiwko@redhat.com">Karel Piwko</a>
  */
-public class AfterDroneCallableCreated extends BaseDroneEvent implements DroneLifecycleEvent {
+public class AfterDronePrepared extends BaseDroneEvent implements DroneConfigurationEvent {
 
-    public AfterDroneCallableCreated(DronePoint<?> dronePoint) {
+    public AfterDronePrepared(DronePoint<?> dronePoint) {
         super(dronePoint);
     }
+
 }