DroneTestEnricher.java

/*
 * JBoss, Home of Professional Open Source
 * Copyright 2010, 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.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jboss.arquillian.drone.impl;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.jboss.arquillian.drone.annotation.ContextPath;
import org.jboss.arquillian.drone.annotation.Drone;
import org.jboss.arquillian.drone.spi.Configurator;
import org.jboss.arquillian.drone.spi.DroneConfiguration;
import org.jboss.arquillian.drone.spi.Instantiator;
import org.jboss.arquillian.impl.configuration.api.ArquillianDescriptor;
import org.jboss.arquillian.spi.TestEnricher;
import org.jboss.arquillian.spi.client.protocol.metadata.HTTPContext;
import org.jboss.arquillian.spi.client.protocol.metadata.ProtocolMetaData;
import org.jboss.arquillian.spi.client.protocol.metadata.Servlet;
import org.jboss.arquillian.spi.core.Instance;
import org.jboss.arquillian.spi.core.annotation.Inject;
import org.jboss.arquillian.spi.util.Validate;

/**
 * Enriches test with drone instance and context path. Injects existing instance
 * into every field annotated with {@link Drone}. Handles enrichements for method
 * arguments as well.
 * 
 * <p>
 * Consumes:
 * </p>
 * <ol>
 * <li>{@link DroneContext}</li>
 * <li>{@link MethodContext}</li>
 * <li>{@link ProtocolMetaData}</li>
 * <li>{@link ArquillianDescriptor}</li>
 * <li>{@link DroneRegistry}</li>
 * </ol>
 * 
 * 
 * @author <a href="kpiwko@redhat.com>Karel Piwko</a>
 * 
 */
public class DroneTestEnricher implements TestEnricher
{
   private static final Logger log = Logger.getLogger(DroneTestEnricher.class.getName());

   @Inject
   private Instance<DroneContext> droneContext;

   @Inject
   private Instance<MethodContext> methodContext;

   @Inject
   private Instance<ProtocolMetaData> protocol;

   @Inject
   private Instance<ArquillianDescriptor> arquillianDescriptor;

   @Inject
   private Instance<DroneRegistry> registry;

   public void enrich(Object testCase)
   {
      List<Field> droneEnrichements = SecurityActions.getFieldsWithAnnotation(testCase.getClass(), Drone.class);
      if (!droneEnrichements.isEmpty())
      {
         Validate.notNull(droneContext.get(), "Drone Test context should not be null");
         droneEnrichement(testCase, droneEnrichements);
      }

      List<Field> contextPathEnrichements = SecurityActions.getFieldsWithAnnotation(testCase.getClass(), ContextPath.class);
      if (!contextPathEnrichements.isEmpty())
      {
         Validate.notNull(protocol.get(), "Protocol Meta Data should not be null");
         contextPathEnrichement(testCase, droneEnrichements);
      }

   }

   public Object[] resolve(Method method)
   {
      Class<?>[] parameterTypes = method.getParameterTypes();
      Annotation[][] parameterAnnotations = method.getParameterAnnotations();
      Object[] resolution = new Object[parameterTypes.length];

      for (int i = 0; i < parameterTypes.length; i++)
      {
         if (SecurityActions.isAnnotationPresent(parameterAnnotations[i], Drone.class))
         {
            if (log.isLoggable(Level.FINE))
            {
               log.fine("Resolving method " + method.getName() + " argument at position " + i);
            }

            Validate.notNull(registry.get(), "Drone registry should not be null");
            Validate.notNull(arquillianDescriptor.get(), "ArquillianDescriptor should not be null");
            Class<? extends Annotation> qualifier = SecurityActions.getQualifier(parameterAnnotations[i]);
            resolution[i] = constructDrone(method, parameterTypes[i], qualifier);
         }
         else if (SecurityActions.isAnnotationPresent(parameterAnnotations[i], ContextPath.class))
         {
            Validate.notNull(protocol.get(), "Protocol Meta data should not be null");
            try
            {
               resolution[i] = getSingularContextPath(protocol.get().getContext(HTTPContext.class), parameterTypes[i]);
            }
            catch (MalformedURLException e)
            {
               throw new IllegalStateException("Could not enrich method " + method.getName() + " with ContextPath", e);
            }
         }
      }

      return resolution;
   }

   private void contextPathEnrichement(Object testCase, List<Field> fields)
   {
      try
      {
         for (Field f : fields)
         {
            // omit setting if already set
            if (f.get(testCase) != null)
            {
               return;
            }

            f.set(testCase, getSingularContextPath(protocol.get().getContext(HTTPContext.class), f.getType()));
         }
      }
      catch (Exception e)
      {
         throw new RuntimeException("Could not inject Drone ContextPath members", e);
      }
   }

   private void droneEnrichement(Object testCase, List<Field> fields)
   {
      try
      {
         for (Field f : fields)
         {
            // omit setting if already set
            if (f.get(testCase) != null)
            {
               return;
            }

            Class<?> typeClass = f.getType();
            Class<? extends Annotation> qualifier = SecurityActions.getQualifier(f);

            Object value = droneContext.get().get(typeClass, qualifier);
            if (value == null)
            {
               throw new IllegalArgumentException("Retrieved a null from context, which is not a valid Drone browser object");
            }

            f.set(testCase, value);
         }
      }
      catch (Exception e)
      {
         throw new RuntimeException("Could not enrich test with Drone members", e);
      }
   }

   private <T> T getSingularContextPath(HTTPContext context, Class<T> returnType) throws IllegalStateException, MalformedURLException
   {
      if (context == null || context.getServlets() == null || context.getServlets().size() == 0)
      {
         throw new IllegalStateException("Unable to retrieve context path for current deployment, no context or servlets found");
      }

      List<Servlet> servlets = context.getServlets();
      String candidate = servlets.get(0).getContextRoot();
      for (Servlet servlet : servlets)
      {
         if (!candidate.equals(servlet.getContextRoot()))
         {
            throw new IllegalStateException("Unable to determine context path for current deployment, multiple servlets present in the deployment");
         }
      }

      // convert URI
      URI uri = servlets.get(0).getBaseURI();
      if (String.class.isAssignableFrom(returnType))
      {
         return returnType.cast(uri.toString());
      }
      else if (URL.class.isAssignableFrom(returnType))
      {
         return returnType.cast(uri.toURL());
      }
      else if (URI.class.isAssignableFrom(returnType))
      {
         return returnType.cast(uri);
      }
      else
      {
         throw new IllegalStateException("Unable to convert URI to " + returnType.getName() + ", it can be injected only to String, URL and URI based fields");
      }

   }

   @SuppressWarnings({ "rawtypes", "unchecked" })
   private Object constructDrone(Method method, Class<?> type, Class<? extends Annotation> qualifier)
   {
      DroneRegistry regs = registry.get();
      ArquillianDescriptor desc = arquillianDescriptor.get();

      Configurator configurator = regs.getConfiguratorFor(type);
      Instantiator instantiator = regs.getInstantiatorFor(type);

      // store in map if not stored already
      DroneContext dc = methodContext.get().getOrCreate(method);

      DroneConfiguration configuration = configurator.createConfiguration(desc, qualifier);
      dc.add(configuration.getClass(), qualifier, configuration);

      Object instance = instantiator.createInstance(configuration);
      dc.add(type, qualifier, instance);

      if (log.isLoggable(Level.FINE))
      {
         log.fine("Stored method lifecycle based Drone instance, type: " + type.getName() + ", qualifier: " + qualifier.getName() + ", instanceClass: " + instance.getClass());
      }

      return instance;
   }
}