com.github.zeger_tak.enversvalidationplugin.execution.AbstractExecutor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of envers-validation-maven-plugin Show documentation
This is a Maven plugin that allows for easy validation of database auditing with Hibernate and is intended to be used by projects that do not always rely on Envers to create the audit history.
There is a newer version: 0.6
Show newest version
package com.github.zeger_tak.enversvalidationplugin.execution;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Nonnull;

import com.github.zeger_tak.enversvalidationplugin.annotation.AuditTableInformationMap;
import com.github.zeger_tak.enversvalidationplugin.annotation.ConnectionProvider;
import com.github.zeger_tak.enversvalidationplugin.annotation.Parameterized;
import com.github.zeger_tak.enversvalidationplugin.annotation.TargetPhase;
import com.github.zeger_tak.enversvalidationplugin.annotation.Validate;
import com.github.zeger_tak.enversvalidationplugin.connection.ConnectionProviderInstance;
import com.github.zeger_tak.enversvalidationplugin.entities.AuditTableInformation;
import com.github.zeger_tak.enversvalidationplugin.entities.ValidationResults;
import com.github.zeger_tak.enversvalidationplugin.exceptions.SetupValidationForSpecificAuditTableInformationException;
import com.github.zeger_tak.enversvalidationplugin.exceptions.ValidationException;
import com.github.zeger_tak.enversvalidationplugin.utils.IgnoreUtils;
import com.github.zeger_tak.enversvalidationplugin.utils.ReflectionUtils;
import org.apache.maven.plugin.logging.Log;

abstract class AbstractExecutor
{
	private final ConnectionProviderInstance connectionProvider;
	private final Log log;
	private final List ignorables;

	AbstractExecutor(@Nonnull ConnectionProviderInstance connectionProvider, @Nonnull Log log, @Nonnull List ignorables)
	{
		this.connectionProvider = connectionProvider;
		this.log = log;
		this.ignorables = ignorables;
	}

	@Nonnull
	private List createValidatorInstances(@Nonnull Class validatorClass, @Nonnull Map auditTableInformationMap, @Nonnull ValidationResults validationResults)
	{
		try
		{
			final List validateMethods = new ArrayList<>();
			Method parameterizedMethod = null;

			for (Method method : validatorClass.getMethods())
			{
				final Validate validate = method.getAnnotation(Validate.class);
				if (validate != null)
				{
					validateMethods.add(method);
					continue;
				}

				final Parameterized parameterized = method.getAnnotation(Parameterized.class);
				if (parameterized != null && Modifier.isStatic(method.getModifiers()))
				{
					if (parameterizedMethod == null)
					{
						parameterizedMethod = method;
					}
					else
					{
						throw new ValidationException(validatorClass.getCanonicalName() + " could not be used for validating, as the class defines more than one " + Parameterized.class.getSimpleName() + " annotated methods.");
					}
				}
			}

			if (parameterizedMethod == null)
			{
				final Object[] constructorArguments = {};
				final Object validatorInstance = createValidatorInstance(validatorClass, constructorArguments, auditTableInformationMap);
				return Collections.singletonList(new SingleValidatorWrapper(validatorInstance, validateMethods));
			}
			else
			{
				try
				{
					final List generatedData = generateDataForConstructorArguments(parameterizedMethod, auditTableInformationMap);
					final List validatorInstances = new ArrayList<>(generatedData.size());
					for (int index = 0; index < generatedData.size(); index++)
					{
						final Object[] constructorArguments = generatedData.get(index);
						final Object validatorInstance = createValidatorInstance(validatorClass, constructorArguments, auditTableInformationMap);
						validatorInstances.add(new ParameterizedValidatorWrapper(validatorInstance, constructorArguments, validateMethods, index));
					}
					return validatorInstances;
				}
				catch (ClassCastException e)
				{
					throw new ValidationException("Unable to create " + validatorClass.getCanonicalName() + " test, because parameterized method " + parameterizedMethod.getName() + " has an invalid return type");
				}
				catch (IllegalAccessException | InvocationTargetException e)
				{
					throw new ValidationException("Unable to create " + validatorClass.getCanonicalName() + " test, because parameterized method " + parameterizedMethod.getName() + " could not be invoked ", e);
				}
			}
		}
		catch (IllegalAccessException | InstantiationException | InvocationTargetException e)
		{
			log.error(TargetPhase.class.getSimpleName() + " " + TargetPhase.SETUP + " could not be instantiated.");
			validationResults.addFailedExecution();
			return Collections.emptyList();
		}
	}

	@Nonnull
	@SuppressWarnings("unchecked")
	private List generateDataForConstructorArguments(@Nonnull Method parameterizedMethod, @Nonnull Map auditTableInformationMap) throws IllegalAccessException, InvocationTargetException
	{
		final List