35 | *
36 | * In both the above cases, EasyTest will measure the time taken by each method of ItemService.
37 | * If the time taken by the method is more than the time specified, the test will fail with appropriate failure reason.
38 | *
52 | *
53 | * In this case, EasyTest will compare the time taken, by the method under test, with the time specified in the Duration annotation,
54 | * only for this test method.
55 | *
56 | * Special case : When the Duration annotation is specified both at the field level and at the method level
57 | *
68 | * In this case, EasyTest will override the timeInMillis value supplied at the field level, with the value supplied at the method level.
69 | * Once the method is finished, it will revert back to the original value specified at the field level. Thus if you have second test method
70 | * that does not have Duration annotation, then the measure of time taken by the method will be 100 milliseconds and not 50 ms.
71 | *
72 | * @author Anuj Kumar
73 | *
74 | */
75 | @Target({ ElementType.FIELD, ElementType.METHOD})
76 | @Retention(RetentionPolicy.RUNTIME)
77 | public @interface Duration {
78 |
79 | /** The time in milliseconds. This is the maximum time a method under test should take to execute */
80 | long timeInMillis();
81 |
82 | /** The Class that should be proxied to provide the time comparison functionality.
83 | * Only required in case the Duration annotation is specified at the test method level.
84 | * Its value will be ignored in case it is specified when the annotation is used at the field level
85 | */
86 | Class forClass() default Empty.class;
87 |
88 | /**
89 | * The {@link MethodInterceptor} to use to intercept method calls.
90 | */
91 | Class interceptor() default DefaultMethodIntercepter.class;
92 |
93 | }
94 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/Format.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | /**
9 | * Annotation that can be used by the user to specify various formating options to be used by EasyTest while
10 | * converting the raw data to a specific object. Currently user has the option to specify the format of date, time and datetime type fields.
11 | *
12 | * @author Anuj Kumar
13 | */
14 | @Retention(RetentionPolicy.RUNTIME)
15 | @Target({ElementType.METHOD , ElementType.TYPE})
16 | public @interface Format {
17 |
18 | /**
19 | * The date formats to be used
20 | */
21 | String[] date() default "dd/MM/yyyy";
22 |
23 | /** The date time formats to be used*/
24 | String[] dateTime() default "dd/MM/yyyy HH:MM:SS";
25 |
26 | /** The time formats to be used*/
27 | String[] time() default "HH:MM:SS";
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/Intercept.java:
--------------------------------------------------------------------------------
1 |
2 | package org.easetech.easytest.annotation;
3 |
4 | import java.lang.annotation.ElementType;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 | import net.sf.cglib.proxy.MethodInterceptor;
9 | import org.easetech.easytest.interceptor.DefaultMethodIntercepter;
10 | import org.easetech.easytest.interceptor.MethodIntercepter;
11 |
12 | /**
13 | *
14 | * A field level annotation that can be used to intercept calls to methods within the subject under test. A user can
15 | * specify the interceptor it wants to use to intercept the call to the test subject's method. The interceptor should
16 | * implement {@link MethodIntercepter}. The default interceptor is {@link DefaultMethodIntercepter} that simply prints
17 | * the time taken in nano seconds by the test method on the console.
18 | * Look here for a simple example :
19 | * https://github.com/EaseTech/easytest-core/blob/master/src/test/java/org/easetech/easytest
20 | * /example/TestExcelDataLoader.java
21 | *
22 | * @author Anuj Kumar
23 | *
24 | */
25 | @Retention(RetentionPolicy.RUNTIME)
26 | @Target({ ElementType.FIELD })
27 | public @interface Intercept {
28 | /**
29 | * The {@link MethodInterceptor} to use to intercept method calls.
30 | */
31 | Class interceptor() default DefaultMethodIntercepter.class;
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/Parallel.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Inherited;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 | import java.util.concurrent.Executors;
9 |
10 | /**
11 | * Class level Annotation that is used
12 | * to run tests in Parallel.
13 | * A user can use the annotation as it is without specifying
14 | * any threads value in which case {@link Executors#newCachedThreadPool()} method is used
15 | * to create a Thread Pool.
16 | * In case the value of threads attribute is specified and it is greater than 0,
17 | * {@link Executors#newFixedThreadPool(int)} method is used to create a fixed thread pool
18 | *
19 | *@author Anuj Kumar
20 | */
21 | @Retention(RetentionPolicy.RUNTIME)
22 | @Target({ElementType.TYPE})
23 | @Inherited
24 | public @interface Parallel {
25 |
26 | /** Number of threads to start while executing the test methods in the given class
27 | * If the value is ZERO or a NEGATIVE number, {@link Executors#newCachedThreadPool()} is used
28 | * to create thread pools else {@link Executors#newFixedThreadPool(int)} is used with the supplied thread count*/
29 | int threads() default 0;
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/ParallelSuite.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Inherited;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 | import java.util.concurrent.Executors;
9 | import org.junit.runners.Suite;
10 |
11 | /**
12 | * {@link Suite} level Annotation that is used
13 | * to run test classes defined in Suite, in Parallel.
14 | * A user can use the annotation as it is without specifying
15 | * any threads value in which case {@link Executors#newCachedThreadPool()} method is used
16 | * to create a Thread Pool.
17 | * In case the value of threads attribute is specified and it is greater than 0,
18 | * {@link Executors#newFixedThreadPool(int)} method is used to create a fixed thread pool
19 | *
20 | *@author Anuj Kumar
21 | */
22 | @Retention(RetentionPolicy.RUNTIME)
23 | @Target({ElementType.TYPE})
24 | @Inherited
25 | public @interface ParallelSuite {
26 |
27 | /** Number of threads to start while executing the test classes in the given suite class
28 | * If the value is ZERO or a NEGATIVE number, {@link Executors#newCachedThreadPool()} is used
29 | * to create thread pools else {@link Executors#newFixedThreadPool(int)} is used with the supplied thread count*/
30 | int threads() default 0;
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/PreserveContext.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | @Retention(RetentionPolicy.RUNTIME)
9 | @Target({ElementType.METHOD})
10 | public @interface PreserveContext {
11 |
12 | boolean value() default true;
13 | }
14 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/Provided.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import javax.inject.Inject;
4 |
5 | import java.lang.annotation.ElementType;
6 | import java.lang.annotation.Retention;
7 | import java.lang.annotation.RetentionPolicy;
8 | import java.lang.annotation.Target;
9 |
10 | /**
11 | * A field level annotation that can be used in the test classes
12 | * to load the values from outside the test class, for example from
13 | * a configuration file. The configuration file is provided to the test class using the
14 | * {@link TestConfigProvider} annotation at the class level.
15 | * The Test Config Provider class should have methods annotated with {@link TestBean} annotations and
16 | * should be public. It is a convenient annotation to support IoC. A user can also use {@link Inject} annotation
17 | * to achieve the same behavior.
18 | *
19 | * @author Anuj Kumar
20 | *
21 | */
22 | @Retention(RetentionPolicy.RUNTIME)
23 | @Target({ElementType.FIELD})
24 | public @interface Provided {
25 |
26 | /** The OPTIONAL name of the bean that should be loaded. If not
27 | * provided then EasyTest framework tries to load the bean using
28 | * the field's type. If the bean with Type is also not found,
29 | * then the framework searches for bean which has the same name as the name of the field
30 | */
31 | String value() default "";
32 |
33 | //Class providerClass() default null;
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/Repeat.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | /**
9 | * Annotation to repeat the test method 'n' times where 'n' is identified by the attribute {@link #times()}
10 | * This annotation can be applied at the test method level and will
11 | * repeat a given test the number of times as specified by the times attribute.
12 | * The test will be executed with exactly the same set of parameters as specified for a single run of the test.
13 | * Note that in case you have specified 3 different input sets for the same test method and also have a Repeat annotation
14 | * on that test method with the {@link #times()} attribute set to 5, then the test will be executed for a total of 15(3 * 5) times.
15 | *
16 | * Currently, there is no way to specify the repeat for a given set of test input.
17 | *
18 | *@author Anuj Kumar
19 | */
20 | @Retention(RetentionPolicy.RUNTIME)
21 | @Target({ElementType.METHOD})
22 | public @interface Repeat {
23 |
24 | /** The number of times a given test method must be repeated*/
25 | int times();
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/Report.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Inherited;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 |
9 | /**
10 | * A test class level annotation providing reporting parameters.
11 | *
12 | * @author Christiaan Mol
13 | *
14 | */
15 | @Retention(RetentionPolicy.RUNTIME)
16 | @Target({ ElementType.TYPE })
17 | @Inherited
18 | public @interface Report {
19 |
20 | public enum EXPORT_FORMAT {
21 | PDF, HTML, XLS
22 | }
23 |
24 | public enum REPORT_TYPE {
25 | DEFAULT, METHOD_DURATION //ALL, PERFORMANCE
26 | }
27 |
28 | /**
29 | * The output path where the reports should be written to. prefix with file:
30 | * will output to filesystem's directory prefix with classpath: will output
31 | * to target classpath
32 | */
33 | String outputLocation() default "";
34 |
35 | /** The output format. Defaults to PDF. */
36 | EXPORT_FORMAT[] outputFormats() default { EXPORT_FORMAT.PDF };
37 |
38 | /** The default report to be outputted */
39 | REPORT_TYPE[] reportTypes() default { REPORT_TYPE.DEFAULT };
40 |
41 | }
42 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/TestBean.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | /**
9 | * A Method level annotation to identify a test bean.
10 | * Since EasyTest supports Inversion of Control, A user can specify
11 | * his test beans in a config class and use the Injection mechanism of easytest to inject these test beans in the test classes.
12 | * Look at {@link Provided} annotation for details. These beans should be defined in the class that is identified by the {@link TestConfigProvider}
13 | *
14 | * @author Anuj Kumar
15 | *
16 | */
17 | @Retention(RetentionPolicy.RUNTIME)
18 | @Target({ElementType.METHOD})
19 | public @interface TestBean {
20 | /**
21 | * Optional name of the bean. If not provided, then
22 | * the return type of the method is used to identify the bean.
23 | * @return the name of the bean
24 | */
25 | String value() default "";
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/TestConfigProvider.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Inherited;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 |
9 | /**
10 | * A Class level annotation used to identify the Test Configuration provider class.
11 | * This annotation is used right at the place where RunWith annotation is used.
12 | *
13 | *@author Anuj Kumar
14 | */
15 | @Retention(RetentionPolicy.RUNTIME)
16 | @Target({ElementType.TYPE})
17 | @Inherited
18 | public @interface TestConfigProvider {
19 |
20 | /**
21 | * An array of Class objects identifying the test config provider class
22 | * @return An array of Class objects identifying the test config provider class
23 | */
24 | Class[] value();
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/TestPolicy.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Inherited;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 | import java.lang.annotation.Target;
8 |
9 | /**
10 | * An extremely useful annotation to define a test class policy.
11 | * A policy of the test class is basically its behavior that drives the test.
12 | * Currently , in EasyTest World, the Test Policy consists of the following annotations :
13 | *
{@link Parallel}
14 | *
{@link TestConfigProvider}
15 | *
{@link Display}
16 | *
{@link DataLoader}
17 | *
{@link Report}
18 | *
{@link Format}
19 | *
20 | *
21 | * Thus a user can define all the above annotation is a separate class and annotate the test class with {@link TestPolicy}
22 | * annotation and define all the class level annotations in the class referenced by the {@link TestPolicy} annotation.
23 | *
24 | * Note that a user can always override the policy specific annotation by defining the individual
25 | * annotations at the test class level. If the annotation is present both in the class referenced in {@link TestPolicy}
26 | * annotation as well as at the test class level, then the annotation at the test class level takes priority over policy level annotation.
27 | *
28 | * @author Anuj Kumar
29 | */
30 | @Retention(RetentionPolicy.RUNTIME)
31 | @Target({ElementType.TYPE})
32 | @Inherited
33 | public @interface TestPolicy {
34 |
35 | /** The class that identifies the Policy associated with the test class */
36 | Class value();
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/TestProperties.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.annotation;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 | import java.util.Properties;
8 |
9 | /**
10 | * A Class level annotation that is applied of Config classes that defines the {@link TestBean}s.
11 | * This annotation is used to load the configuration properties, if any, for the test configuration.
12 | * This annotation can be used both on the Config classes as well as on the actual Test classes.
13 | * When you use this annotation, be sure to provide a field of type {@link Properties}
14 | * in the class on which the annotation is used. This property will be provided the value of the loaded Properties
15 | * at runtime by the framework.
16 | *
17 | * NOTE: For the moment the annotation does not work properly at the class level. This is a known bug and will be fixed in a future release.
18 | *
19 | *
20 | *@author Anuj Kumar
21 | */
22 | @Retention(RetentionPolicy.RUNTIME)
23 | @Target({ElementType.TYPE , ElementType.FIELD})
24 | public @interface TestProperties {
25 |
26 | /**
27 | * The array of file paths from where to load the resource.
28 | *
29 | */
30 | String[] value();
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/annotation/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Package containing EasyTest specific annotations.
3 | *
4 | *
5 | */
6 |
7 | package org.easetech.easytest.annotation;
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/BaseConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 |
4 | /**
5 | *
6 | * A base Converter for all the converters in EasyTest.
7 | *
8 | * @param the data to convert from
9 | * @param the data to convert to
10 | *
11 | * @author Anuj Kumar
12 | */
13 | public interface BaseConverter {
14 |
15 | /**
16 | * Constant for Empty String
17 | */
18 | public static final String EMPTY_STRING = "";
19 |
20 |
21 |
22 | public static final String COLON = ":";
23 |
24 | /**
25 | * Convert the passed object into a user defined data.
26 | * @param convertFrom the object to convert from
27 | * @return the object to convert to
28 | */
29 | TO convert(FROM convertFrom);
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/Converter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import java.util.Map;
4 |
5 | /**
6 | *
7 | * A generic interface responsible for converting a Map object into a user defined object.
8 | * The Map object is of type Map<String,List<Map<String,Object>>>
9 | * It can be read as Map of MethodName as KEY and List of Map of MethodAttributes/MethodAttributeValues as Value.
10 | * Users should normally extend {@link AbstractConverter} instead of implementing this interface as the abstract converter
11 | * has implementation to methods {@link #convertTo()} and {@link #instanceOfType()}
12 | *
13 | * For an example of writing a converter, look at :
14 | * https://github.com/EaseTech/easytest-core/blob/master/src/test/java/org/easetech/easytest/example/ItemConverter.java
15 | *
16 | * @param the type of object to convert to from a map.
17 | *
18 | * @author Anuj Kumar
19 | */
20 | public interface Converter extends BaseConverter, TO>{
21 |
22 | /**
23 | * The class of the generic type argument to which the data should be converted to.
24 | * @return the class of the object to convert to
25 | */
26 | Class convertTo();
27 |
28 | /**
29 | * Convert the Map into a user defined object.
30 | * @param convertFrom the {@link Map} to convert from
31 | * @return the object to convert to identified by {@link #convertTo()} class.
32 | */
33 | TO convert(Map convertFrom);
34 |
35 | /**
36 | * Method responsible for returning an instance of the provided Generic Type argument.
37 | * Look at {@link AbstractConverter#instanceOfType()} methods Javadoc for details on the default implementation.
38 | * @return an instance of the provided Generic Type argument.
39 | */
40 | TO instanceOfType();
41 |
42 | }
43 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/ConverterManager.java:
--------------------------------------------------------------------------------
1 |
2 | package org.easetech.easytest.converter;
3 |
4 | import java.util.HashSet;
5 | import java.util.Iterator;
6 | import java.util.Set;
7 |
8 | /**
9 | * A class that manages the registered Converters and makes them available to the framework.
10 | * This class can be used to locate a {@link Converter} for any given type name.
11 | *
12 | * @author Anuj Kumar
13 | *
14 | */
15 | @SuppressWarnings("rawtypes")
16 | public class ConverterManager {
17 |
18 | /**
19 | * A thread local variable that will hold the set of {@link Converter} for easy consumption by the test cases.
20 | */
21 | public static final InheritableThreadLocal> converters = new InheritableThreadLocal>();
22 |
23 | /**
24 | * Find the registered Converter for the given class type
25 | *
26 | * @param targetType the class type to find teh converter for.
27 | * @return an instance of registered converter or Null if not found.
28 | */
29 | public static Converter findConverter(Class targetType) {
30 |
31 | Set cnvrtrs = converters.get();
32 | Converter result = null;
33 | if (cnvrtrs != null) {
34 | Iterator itr = cnvrtrs.iterator();
35 |
36 | while (itr.hasNext()) {
37 | Converter converter = itr.next();
38 | if (converter.convertTo().equals(targetType)) {
39 | result = converter;
40 | break;
41 | }
42 | }
43 | }
44 |
45 | return result;
46 | }
47 |
48 | /**
49 | * Register the converter with the ConverterManager
50 | *
51 | * @param converterClass the class object identifying the concrete {@link Converter} class.
52 | */
53 | public static void registerConverter(Class converterClass) {
54 | Set cnvrtrs = converters.get();
55 | if (cnvrtrs == null) {
56 | cnvrtrs = new HashSet();
57 | }
58 | if (converterClass != null && Converter.class.isAssignableFrom(converterClass)) {
59 | Converter converter = null;
60 | try {
61 | converter = (Converter) converterClass.newInstance();
62 | cnvrtrs.add(converter);
63 | converters.set(cnvrtrs);
64 | } catch (InstantiationException e) {
65 | throw new RuntimeException(
66 | "InstantiationException occured while trying to register a converter with class : "
67 | + converterClass, e);
68 | } catch (IllegalAccessException e) {
69 | throw new RuntimeException(
70 | "IllegalAccessException occured while trying to register a converter with class : "
71 | + converterClass, e);
72 | }
73 |
74 | } else {
75 | throw new RuntimeException("Could not register the converter for " + converterClass
76 | + " . Either the passed argument is NULL or the passed class does not extend the "
77 | + AbstractConverter.class.getSimpleName() + " abstract class or implement the "
78 | + Converter.class.getSimpleName() + " interface.");
79 | }
80 |
81 | }
82 |
83 | /**
84 | * Clean the thread local variable
85 | */
86 | public static void cleanConverters() {
87 | converters.remove();
88 | }
89 |
90 | }
91 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/ConverterSupport.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import org.easetech.easytest.internal.DateTimeFormat;
4 |
5 | /**
6 | * A convenient support class that gives users access to various defined
7 | * parameters that may be useful during data conversion
8 | */
9 | public class ConverterSupport {
10 |
11 | /** The name of the parameter to which this converter is serving */
12 | private String paramName;
13 |
14 | /**
15 | * Whether empty values should be converted to Null values or not
16 | */
17 | private Boolean convertEmptyToNull;
18 |
19 | /**
20 | * The user specified date time format to use
21 | */
22 | private DateTimeFormat dateTimeFormat;
23 |
24 | /**
25 | * The name of the parameter to which this converter is serving
26 | * @return the paramName
27 | */
28 | public String getParamName() {
29 | return paramName;
30 | }
31 |
32 | /**
33 | * The name of the parameter to which this converter is serving
34 | * @param paramName the paramName to set
35 | */
36 | public void setParamName(String paramName) {
37 | this.paramName = paramName;
38 | }
39 |
40 | /**
41 | * Whether empty values should be converted to Null values or not
42 | * @return the convertEmptyToNull
43 | */
44 | public Boolean getConvertEmptyToNull() {
45 | return convertEmptyToNull;
46 | }
47 |
48 | /**
49 | * Whether empty values should be converted to Null values or not
50 | * @param convertEmptyToNull the convertEmptyToNull to set
51 | */
52 | public void setConvertEmptyToNull(Boolean convertEmptyToNull) {
53 | this.convertEmptyToNull = convertEmptyToNull;
54 | }
55 |
56 | /**
57 | * The user specified date time format to use
58 | * @return the dateTimeFormat
59 | */
60 | public DateTimeFormat getDateTimeFormat() {
61 | return dateTimeFormat;
62 | }
63 |
64 | /**
65 | * The user specified date time format to use
66 | * @param dateTimeFormat the dateTimeFormat to set
67 | */
68 | public void setDateTimeFormat(DateTimeFormat dateTimeFormat) {
69 | this.dateTimeFormat = dateTimeFormat;
70 | }
71 |
72 |
73 | }
74 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/DataAlreadyConvertedConverter.java:
--------------------------------------------------------------------------------
1 |
2 | package org.easetech.easytest.converter;
3 |
4 | import org.slf4j.Logger;
5 | import org.slf4j.LoggerFactory;
6 |
7 | import java.util.ArrayList;
8 | import org.easetech.easytest.util.GeneralUtil;
9 |
10 | import java.util.List;
11 | import java.util.Map;
12 | import org.junit.experimental.theories.PotentialAssignment;
13 |
14 | /**
15 | *
16 | * An instance of {@link BaseConverter} that is responsible for getting the already converted data and
17 | * creating a list of {@link PotentialAssignment}s that is understood by EasyTest Framework.
18 | *
19 | * @author Anuj Kumar
20 | *
21 | */
22 | public class DataAlreadyConvertedConverter implements
23 | BaseConverter>, List> {
24 |
25 | /**
26 | * Logger
27 | */
28 | private static final Logger LOG = LoggerFactory.getLogger(DataAlreadyConvertedConverter.class);
29 |
30 | /**
31 | * The type of parameter to convert the raw data to
32 | */
33 | private final Class parameterType;
34 |
35 | /**
36 | * The name of the parameter that is being converted
37 | */
38 | private final String paramName;
39 |
40 | /**
41 | * Whether empty values should be converted to Null values or not
42 | */
43 | private final Boolean convertEmptyToNull;
44 |
45 | /**
46 | *
47 | * Construct a new DataAlreadyConvertedConverter
48 | * @param parameterType The type of parameter to convert the raw data to
49 | * @param paramName The name of the parameter that is being converted
50 | * @param convertEmptyToNull Whether empty values should be converted to Null values or not
51 | */
52 | public DataAlreadyConvertedConverter(Class parameterType, String paramName, Boolean convertEmptyToNull) {
53 | super();
54 | this.parameterType = parameterType;
55 | this.paramName = paramName;
56 | this.convertEmptyToNull = convertEmptyToNull;
57 | }
58 |
59 | /**
60 | * Handle the data that has already been converted by the user.
61 | * @param convertFrom the data to handle
62 | * @return the list of PotentialAssignemnts
63 | */
64 | public List convert(List> convertFrom) {
65 | LOG.debug("Trying to verify whether the data has already been converted by the user or not");
66 | List potentialAssignments = null;
67 | if (GeneralUtil.dataAlreadyConverted(parameterType, convertFrom, paramName)) {
68 | LOG.debug("Data is converted by the user. Filling it up");
69 | potentialAssignments = new ArrayList();
70 | Object value = null;
71 | for (Map object : convertFrom) {
72 | if (String.class.isAssignableFrom(parameterType)) {
73 | if (convertEmptyToNull) {
74 | if (object.get(paramName) != null && "".equals(object.get(paramName).toString())) {
75 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, value));
76 | } else {
77 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, object.get(paramName)));
78 | }
79 | } else {
80 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, object.get(paramName)));
81 | }
82 | } else {
83 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, object.get(paramName)));
84 | }
85 |
86 | }
87 | }
88 | return potentialAssignments;
89 | }
90 |
91 | }
92 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/JSONDataConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 | import java.util.Map;
6 | import org.easetech.easytest.util.GeneralUtil;
7 | import org.junit.experimental.theories.PotentialAssignment;
8 | import org.slf4j.Logger;
9 | import org.slf4j.LoggerFactory;
10 |
11 | /**
12 | *
13 | * An instance of {@link BaseConverter} that is responsible for converting the raw JSON data in to auser defined type instance
14 | *
15 | * @author Anuj Kumar
16 | *
17 | */
18 | public class JSONDataConverter implements BaseConverter>, List> {
19 |
20 | /**
21 | * The type of parameter to convert to
22 | */
23 | private final Class parameterType;
24 |
25 | /**
26 | * The name of the parameter that is being converted
27 | */
28 | private final String paramName;
29 |
30 | /**
31 | * Logger
32 | */
33 | private static final Logger LOG = LoggerFactory.getLogger(JSONDataConverter.class);
34 |
35 | /**
36 | *
37 | * Construct a new JSONDataConverter
38 | * @param parameterType The type of parameter to convert to
39 | * @param paramName The name of the parameter that is being converted
40 | */
41 | public JSONDataConverter(Class parameterType, String paramName) {
42 | this.parameterType = parameterType;
43 | this.paramName = paramName;
44 | }
45 |
46 | /**
47 | * Convert the raw data into a list of {@link PotentialAssignment} instance
48 | * that EasyTest uses to provide the right set of test data to the test method
49 | * @param convertFrom the raw data to convert from
50 | * @return the list of {@link PotentialAssignment} instances
51 | */
52 | public List convert(List> convertFrom) {
53 | LOG.debug("Trying to see if the provided data is JSON Data. ");
54 | List potentialAssignments = new ArrayList();
55 | Boolean populated = GeneralUtil.populateJSONData(parameterType , convertFrom, potentialAssignments, paramName);
56 | if(!populated) {
57 | potentialAssignments = null;
58 | }
59 | return potentialAssignments;
60 | }
61 |
62 | }
63 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/MapConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 | import java.util.Map;
6 | import org.junit.experimental.theories.PotentialAssignment;
7 | import org.slf4j.Logger;
8 | import org.slf4j.LoggerFactory;
9 |
10 | /**
11 | *
12 | * An instance of {@link BaseConverter} that is responsible for converting the raw data in to a user defined Map type instance
13 | *
14 | * @author Anuj Kumar
15 | *
16 | */
17 | public class MapConverter implements BaseConverter> , List> {
18 |
19 | /**
20 | * Logger
21 | */
22 | private static final Logger LOG = LoggerFactory.getLogger(MapConverter.class);
23 |
24 | /**
25 | * The type of Map to convert to
26 | */
27 | private final Class mapType;
28 |
29 | /**
30 | *
31 | * Construct a new MapConverter
32 | * @param mapType the type of map to convert to
33 | */
34 | public MapConverter(Class mapType) {
35 | this.mapType = mapType;
36 | }
37 |
38 |
39 | /**
40 | * Convert the given list of raw data to a list of map instance
41 | * @param convertFrom the data to convert from
42 | * @return the list of {@link PotentialAssignment}
43 | */
44 | @SuppressWarnings("unchecked")
45 | public List convert(List> convertFrom) {
46 | List potentialAssignments = null;
47 | if (Map.class.isAssignableFrom(mapType)) {
48 | potentialAssignments = new ArrayList();
49 | for (Map map : convertFrom) {
50 | if (mapType.isInterface()) {
51 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, map));
52 | } else {
53 | Map dataValues;
54 | try {
55 | dataValues = (Map) mapType.newInstance();
56 | } catch (Exception e) {
57 | LOG.error(
58 | "Exception occured while trying to convert the data to Map(using newInstance() method). "
59 | + "The type of Map passed as input parameter is :" + mapType, e);
60 | throw new RuntimeException(e);
61 | }
62 | dataValues.putAll(map);
63 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, dataValues));
64 | }
65 |
66 | }
67 | }
68 |
69 | return potentialAssignments;
70 | }
71 |
72 | }
73 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/ParamAwareConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import java.util.Map;
4 |
5 | /**
6 | * Decorator of {@link Converter} to provide the name of the parameter
7 | * to the implementing class. Users who are extending from {@link AbstractConverter}
8 | * will have no effect on their existing converters. On top of that they will now
9 | * have access to the parameter name using the {@link AbstractConverter#getParamName()} method.
10 | * Users who are directly implementing {@link Converter} interface will have to switch to either
11 | * {@link ParamAwareConverter} or {@link AbstractConverter} to get the parameter name.
12 | *
13 | * @param the type of object to convert to from a map.
14 | *
15 | * @author Anuj Kumar
16 | */
17 | public interface ParamAwareConverter extends Converter {
18 |
19 | /**
20 | * Convert the Map into a user defined object and also expect the param name
21 | * @param convertFrom the {@link Map} to convert from
22 | * @param paramName the name of the parameter for which this converter is called
23 | * @return the object to convert to identified by {@link #convertTo()} class.
24 | */
25 | Type convert(Map convertFrom , String paramName);
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/ParamConstructorConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import org.easetech.easytest.internal.DateTimeFormat;
4 |
5 | import java.util.ArrayList;
6 | import java.util.Collection;
7 | import java.util.List;
8 | import java.util.Map;
9 | import org.easetech.easytest.util.GeneralUtil;
10 | import org.junit.experimental.theories.PotentialAssignment;
11 | import org.slf4j.Logger;
12 | import org.slf4j.LoggerFactory;
13 |
14 | /**
15 | *
16 | * An instance of {@link BaseConverter} that is responsible for converting the raw data in to a user defined type instance
17 | * using the type's constructor
18 | *
19 | * @author Anuj Kumar
20 | *
21 | */
22 | public class ParamConstructorConverter implements BaseConverter>, List> {
23 |
24 | /**
25 | * The type of parameter to convert to
26 | */
27 | private final Class parameterType;
28 |
29 | /**
30 | * The name of the parameter that is being converted
31 | */
32 | private final String paramName;
33 |
34 | /**
35 | * The optional collection instance in case of Collection type parameter
36 | */
37 | private final Collection collection;
38 |
39 | /**
40 | * Whether empty values should be converted to null or not
41 | */
42 | private final Boolean convertEmptyToNull;
43 |
44 | /**
45 | * the user specified date time format to use
46 | */
47 | private final DateTimeFormat dateTimeFormat;
48 |
49 | /**
50 | * Logger
51 | */
52 | private static final Logger LOG = LoggerFactory.getLogger(JSONDataConverter.class);
53 |
54 | /**
55 | *
56 | * Construct a new ParamConstructorConverter
57 | * @param parameterType The type of parameter to convert to
58 | * @param paramName The name of the parameter that is being converted
59 | * @param collection The optional collection instance in case of Collection type parameter
60 | * @param convertEmptyToNull whether empty string be converted to null or not
61 | * @param dateTimeFormat the user specified date time format to use
62 | */
63 | public ParamConstructorConverter(Class parameterType, String paramName, Collection collection, Boolean convertEmptyToNull , DateTimeFormat dateTimeFormat) {
64 | this.parameterType = parameterType;
65 | this.paramName = paramName;
66 | this.collection = collection;
67 | this.convertEmptyToNull = convertEmptyToNull;
68 | this.dateTimeFormat = dateTimeFormat;
69 | }
70 |
71 | /**
72 | * Convert the raw data into a list of {@link PotentialAssignment} instance
73 | * that EasyTest uses to provide the right set of test data to the test method
74 | * @param convertFrom the raw data to convert from
75 | * @return the list of {@link PotentialAssignment} instances
76 | */
77 | public List convert(List> convertFrom) {
78 | LOG.debug("Trying to call the constructor, if any of the class {} to populate the data" , parameterType);
79 | List potentialAssignments = new ArrayList();
80 | Boolean populated = false;
81 | try {
82 | populated = GeneralUtil.fillDataUsingConstructor(parameterType, convertFrom, potentialAssignments, paramName, collection , convertEmptyToNull , dateTimeFormat);
83 | } catch (Exception e) {
84 | LOG.debug("Exception occured while trying to populate the data by instantiating the parameter object" , e);
85 | potentialAssignments = null;
86 | }
87 | if(!populated) {
88 | potentialAssignments = null;
89 | }
90 | return potentialAssignments;
91 |
92 | }
93 |
94 | }
95 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/PropertyEditorCollectionConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import java.beans.PropertyEditor;
4 | import java.beans.PropertyEditorManager;
5 | import java.util.ArrayList;
6 | import java.util.Collection;
7 | import java.util.List;
8 | import java.util.Map;
9 | import org.easetech.easytest.internal.EasyParamSignature;
10 | import org.easetech.easytest.util.GeneralUtil;
11 | import org.junit.experimental.theories.PotentialAssignment;
12 | import org.slf4j.Logger;
13 | import org.slf4j.LoggerFactory;
14 |
15 | /**
16 | *
17 | * An instance of {@link BaseConverter} that is responsible for converting the raw data in to a user defined type instance
18 | * using any registered Property Editors
19 | *
20 | * @author Anuj Kumar
21 | *
22 | */
23 | public class PropertyEditorCollectionConverter implements BaseConverter>, List> {
24 |
25 | /**
26 | * an instance of {@link EasyParamSignature}
27 | */
28 | private final EasyParamSignature signature;
29 |
30 | /**
31 | * The name of the parameter that is being converted
32 | */
33 | private final String paramName;
34 |
35 | /**
36 | * The collection instance in case of Collection type parameter
37 | */
38 | private final Collection collection;
39 |
40 |
41 | /**
42 | * Logger
43 | */
44 | private static final Logger LOG = LoggerFactory.getLogger(PropertyEditorCollectionConverter.class);
45 |
46 | /**
47 | *
48 | * Construct a new PropertyEditorCollectionConverter
49 | * @param signature an instance of {@link EasyParamSignature}
50 | * @param paramName The name of the parameter that is being converted
51 | * @param collection The collection instance in case of Collection type parameter
52 | */
53 | public PropertyEditorCollectionConverter(EasyParamSignature signature, String paramName, Collection collection) {
54 | super();
55 | this.signature = signature;
56 | this.paramName = paramName;
57 | this.collection = collection;
58 | }
59 |
60 | /**
61 | * Convert the raw data into a list of {@link PotentialAssignment} instance
62 | * that EasyTest uses to provide the right set of test data to the test method
63 | * @param convertFrom the raw data to convert from
64 | * @return the list of {@link PotentialAssignment} instances
65 | */
66 | @SuppressWarnings("unchecked")
67 | public List convert(List> convertFrom) {
68 | List potentialAssignments = null;
69 | Class genericType = signature.getIsGenericParameter() ? signature.getGenericParameterArgType()
70 | : Object.class;
71 | PropertyEditor editor = PropertyEditorManager.findEditor(genericType);
72 | if (editor != null) {
73 | potentialAssignments = new ArrayList();
74 | LOG.debug("Editor for class {} found", genericType);
75 | for (Map object : convertFrom) {
76 | String strValue;
77 | if (paramName != null && !EMPTY_STRING.equals(paramName)) {
78 | strValue = GeneralUtil.getStringValue(paramName, object);
79 | } else {
80 | strValue = GeneralUtil.getStringValue(genericType.getSimpleName(), object);
81 | }
82 | if (strValue != null) {
83 | String[] values = strValue.split(COLON);
84 | for (int i = 0; i < values.length; i++) {
85 | editor.setAsText(values[i]);
86 | if (editor.getValue() != null) {
87 | collection.add(editor.getValue());
88 | }
89 | }
90 | }
91 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, collection));
92 | }
93 |
94 | }
95 | return potentialAssignments;
96 | }
97 |
98 |
99 |
100 | }
101 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/PropertyEditorConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import java.beans.PropertyEditor;
4 | import java.beans.PropertyEditorManager;
5 | import java.util.ArrayList;
6 | import java.util.List;
7 | import java.util.Map;
8 | import org.easetech.easytest.util.GeneralUtil;
9 | import org.junit.experimental.theories.PotentialAssignment;
10 | import org.slf4j.Logger;
11 | import org.slf4j.LoggerFactory;
12 |
13 | /**
14 | *
15 | * An instance of {@link BaseConverter} that is responsible for converting the raw data in to a user defined type instance
16 | * using any registered Property Editors
17 | *
18 | * @author Anuj Kumar
19 | *
20 | */
21 | public class PropertyEditorConverter implements BaseConverter>, List> {
22 |
23 | /**
24 | * Logger
25 | */
26 | private static final Logger LOG = LoggerFactory.getLogger(PropertyEditorConverter.class);
27 |
28 | /**
29 | * The type of parameter to convert the raw data to
30 | */
31 | private final Class parameterType;
32 |
33 | /**
34 | * The name of the parameter that is being converted
35 | */
36 | private final String paramName;
37 |
38 | /**
39 | *
40 | * Construct a new PropertyEditorConverter
41 | * @param parameterType The type of parameter to convert the raw data to
42 | * @param paramName The name of the parameter that is being converted
43 | */
44 | public PropertyEditorConverter(Class parameterType, String paramName) {
45 | this.parameterType = parameterType;
46 | this.paramName = paramName;
47 | }
48 |
49 | /**
50 | * Convert the raw data into a list of {@link PotentialAssignment} instance
51 | * that EasyTest uses to provide the right set of test data to the test method
52 | * @param convertFrom the raw data to convert from
53 | * @return the list of {@link PotentialAssignment} instances
54 | */
55 | public List convert(List> convertFrom) {
56 | LOG.debug("Trying to convert the data using any registered Property Editors. The class responsible for conversion is {}" , PropertyEditorConverter.class.getSimpleName());
57 | List potentialAssignments = null;
58 | PropertyEditor editor = PropertyEditorManager.findEditor(parameterType);
59 | if (editor != null) {
60 | potentialAssignments = new ArrayList();
61 | LOG.debug("Editor for class {} found", parameterType);
62 | for (Map object : convertFrom) {
63 | if (paramName != null && !EMPTY_STRING.equals(paramName)) {
64 | if (GeneralUtil.getStringValue(paramName, object) != null) {
65 | editor.setAsText(GeneralUtil.getStringValue(paramName, object));
66 | }
67 |
68 | } else {
69 | if(GeneralUtil.getStringValue(parameterType.getSimpleName(), object) != null){
70 | editor.setAsText(GeneralUtil.getStringValue(parameterType.getSimpleName(), object));
71 | }
72 | }
73 | // add data to PotentialAssignment even if it is null
74 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, editor.getValue()));
75 |
76 | }
77 |
78 | }
79 | return potentialAssignments;
80 | }
81 |
82 |
83 | }
84 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/StandardObjectCollectionConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import org.easetech.easytest.internal.DateTimeFormat;
4 |
5 | import java.util.ArrayList;
6 | import java.util.Collection;
7 | import java.util.List;
8 | import java.util.Map;
9 | import org.easetech.easytest.internal.EasyParamSignature;
10 | import org.easetech.easytest.util.GeneralUtil;
11 | import org.junit.experimental.theories.PotentialAssignment;
12 | import org.slf4j.Logger;
13 | import org.slf4j.LoggerFactory;
14 |
15 | /**
16 | *
17 | * An instance of {@link BaseConverter} that is responsible for converting the raw data in to a user defined type instance
18 | * using any jav standard object
19 | *
20 | * @author Anuj Kumar
21 | *
22 | */
23 | public class StandardObjectCollectionConverter implements BaseConverter>, List> {
24 |
25 | /**
26 | * The collection instance in case of Collection type parameter
27 | */
28 | private final Collection collection;
29 |
30 | /**
31 | * an instance of {@link EasyParamSignature}
32 | */
33 | private final EasyParamSignature signature;
34 |
35 | /**
36 | * The name of the parameter that is being converted
37 | */
38 | private final String paramName;
39 |
40 | /**
41 | * Whether empty values should be converted to Null values or not
42 | */
43 | private final Boolean convertEmptyToNull;
44 |
45 | /**
46 | * User specified date time format to use
47 | */
48 | private final DateTimeFormat dateTimeFormat;
49 |
50 | /**
51 | *
52 | * Construct a new StandardObjectCollectionConverter
53 | * @param collection The collection instance in case of Collection type parameter
54 | * @param signature an instance of {@link EasyParamSignature}
55 | * @param paramName The name of the parameter that is being converted
56 | * @param convertEmptyToNull whether empty values be converted to null or not
57 | * @param dateTimeFormat user specified date time format
58 | */
59 | public StandardObjectCollectionConverter(Collection collection, EasyParamSignature signature, String paramName , Boolean convertEmptyToNull , DateTimeFormat dateTimeFormat) {
60 | super();
61 | this.collection = collection;
62 | this.signature = signature;
63 | this.paramName = paramName;
64 | this.convertEmptyToNull = convertEmptyToNull;
65 | this.dateTimeFormat = dateTimeFormat;
66 | }
67 |
68 | /**
69 | * Logger
70 | */
71 | private static final Logger LOG = LoggerFactory.getLogger(StandardObjectCollectionConverter.class);
72 |
73 | /**
74 | * Convert the raw data into a list of {@link PotentialAssignment} instance
75 | * that EasyTest uses to provide the right set of test data to the test method
76 | * @param convertFrom the raw data to convert from
77 | * @return the list of {@link PotentialAssignment} instances
78 | */
79 | @SuppressWarnings({ "unchecked" })
80 | public List convert(List> convertFrom) {
81 | List potentialAssignments = null;
82 | Class genericType = signature.getIsGenericParameter() ? signature.getGenericParameterArgType()
83 | : Object.class;
84 | if (GeneralUtil.isStandardObjectInstance(genericType)) {
85 | potentialAssignments = new ArrayList();
86 | LOG.debug(
87 | "parameter to the collection is a Standard Java Class {} . Using Internal Editors to resolve values",
88 | genericType);
89 |
90 | for (Map object : convertFrom) {
91 | String[] strValues = ((String) object.get(paramName)).split(COLON);
92 | for (int i = 0; i < strValues.length; i++) {
93 | collection.add(GeneralUtil.convertToTargetType(genericType, strValues[i], convertEmptyToNull , dateTimeFormat));
94 | }
95 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, collection));
96 | }
97 | }
98 | return potentialAssignments;
99 |
100 | }
101 |
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/StandardObjectConverter.java:
--------------------------------------------------------------------------------
1 |
2 | package org.easetech.easytest.converter;
3 |
4 | import org.easetech.easytest.internal.DateTimeFormat;
5 |
6 | import java.util.ArrayList;
7 | import java.util.List;
8 | import java.util.Map;
9 | import org.easetech.easytest.util.GeneralUtil;
10 | import org.junit.experimental.theories.PotentialAssignment;
11 | import org.slf4j.Logger;
12 | import org.slf4j.LoggerFactory;
13 |
14 | /**
15 | *
16 | * An instance of {@link BaseConverter} that is responsible for converting the raw data in to a user defined type instance
17 | * using any java standard object
18 | *
19 | * @author Anuj Kumar
20 | *
21 | */
22 | public class StandardObjectConverter implements BaseConverter>, List> {
23 |
24 | /**
25 | * The type of parameter to convert the raw data to
26 | */
27 | private final Class parameterType;
28 |
29 | /**
30 | * The name of the parameter that is being converted
31 | */
32 | private final String paramName;
33 |
34 | /**
35 | * Whether empty values should be converted to Null values or not
36 | */
37 | private final Boolean convertEmptyToNull;
38 |
39 | /**
40 | * The user specified date time format to use
41 | */
42 | private final DateTimeFormat dateTimeFormat;
43 |
44 | /**
45 | * Logger
46 | */
47 | private static final Logger LOG = LoggerFactory.getLogger(StandardObjectConverter.class);
48 |
49 | /**
50 | *
51 | * Construct a new StandardObjectConverter
52 | * @param parameterType The type of parameter to convert the raw data to
53 | * @param paramName The name of the parameter that is being converted
54 | * @param convertEmptyToNull Whether empty values should be converted to Null values or not
55 | * @param dateTimeFormat The user specified date time format to use
56 | */
57 | public StandardObjectConverter(Class parameterType, String paramName , Boolean convertEmptyToNull , DateTimeFormat dateTimeFormat) {
58 | this.parameterType = parameterType;
59 | this.paramName = paramName;
60 | this.convertEmptyToNull = convertEmptyToNull;
61 | this.dateTimeFormat = dateTimeFormat;
62 | }
63 |
64 | /**
65 | * Convert the raw data into a list of {@link PotentialAssignment} instance
66 | * that EasyTest uses to provide the right set of test data to the test method
67 | * @param convertFrom the raw data to convert from
68 | * @return the list of {@link PotentialAssignment} instances
69 | */
70 | public List convert(List> convertFrom) {
71 | LOG.debug("Trying to convert the data to a standard Object instance using {}" , StandardObjectConverter.class.getSimpleName());
72 | List potentialAssignments = null;
73 | if (GeneralUtil.isStandardObjectInstance(parameterType)) {
74 | potentialAssignments = new ArrayList();
75 | for (Map object : convertFrom) {
76 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING,
77 | GeneralUtil.convertToTargetType(parameterType, object.get(paramName) , convertEmptyToNull, dateTimeFormat)));
78 | }
79 | }
80 |
81 | return potentialAssignments;
82 | }
83 |
84 | }
85 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/UserDefinedCollectionConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import java.util.ArrayList;
4 | import java.util.Collection;
5 | import java.util.HashMap;
6 | import java.util.List;
7 | import java.util.Map;
8 | import org.easetech.easytest.internal.EasyParamSignature;
9 | import org.junit.experimental.theories.PotentialAssignment;
10 | import org.slf4j.Logger;
11 | import org.slf4j.LoggerFactory;
12 |
13 | /**
14 | *
15 | * An instance of {@link BaseConverter} that is responsible for converting the raw data in to a user defined type instance
16 | * using any user defined converter
17 | *
18 | * @author Anuj Kumar
19 | *
20 | */
21 | public class UserDefinedCollectionConverter implements BaseConverter>, List> {
22 |
23 |
24 | /**
25 | * The collection instance in case of Collection type parameter
26 | */
27 | private final Collection collection;
28 |
29 | /**
30 | * an instance of {@link EasyParamSignature}
31 | */
32 | private final EasyParamSignature signature;
33 |
34 | /**
35 | * The name of the parameter that is being converted
36 | */
37 | private final String paramName;
38 |
39 |
40 | /**
41 | *
42 | * Construct a new UserDefinedCollectionConverter
43 | * @param signature an instance of {@link EasyParamSignature}
44 | * @param paramName The name of the parameter that is being converted
45 | * @param collection The collection instance in case of Collection type parameter
46 | */
47 | public UserDefinedCollectionConverter(EasyParamSignature signature, String paramName, Collection collection) {
48 | super();
49 | this.signature = signature;
50 | this.paramName = paramName;
51 | this.collection = collection;
52 | }
53 |
54 | /**
55 | * Logger
56 | */
57 | private static final Logger LOG = LoggerFactory.getLogger(UserDefinedCollectionConverter.class);
58 |
59 | /**
60 | * Convert the raw data into a list of {@link PotentialAssignment} instance
61 | * that EasyTest uses to provide the right set of test data to the test method
62 | * @param convertFrom the raw data to convert from
63 | * @return the list of {@link PotentialAssignment} instances
64 | */
65 | @SuppressWarnings("unchecked")
66 | public List convert(List> convertFrom) {
67 |
68 | List potentialAssignments = null;
69 | Class genericType = signature.getIsGenericParameter() ? signature.getGenericParameterArgType()
70 | : Object.class;
71 | LOG.debug("Editor for class {} not found. Trying to find converter.", genericType);
72 | Converter converter = ConverterManager.findConverter(genericType);
73 | if (converter != null) {
74 | potentialAssignments = new ArrayList();
75 | LOG.debug("Converter for class {} found ", genericType);
76 | for (Map object : convertFrom) {
77 | Map tempMap = new HashMap();
78 | String values = (String) object.get(paramName);
79 | String[] splitValues = values.split(COLON);
80 | for (int i = 0; i < splitValues.length; i++) {
81 | tempMap.put(paramName, splitValues[i]);
82 | Object value;
83 | if(converter instanceof ParamAwareConverter) {
84 | value = ((ParamAwareConverter)converter).convert(tempMap, paramName);
85 | } else {
86 | value = converter.convert(tempMap);
87 | }
88 | collection.add(value);
89 | }
90 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, collection));
91 | }
92 | }
93 | return potentialAssignments;
94 | }
95 |
96 | }
97 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/UserDefinedConverter.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.converter;
2 |
3 | import org.easetech.easytest.internal.DateTimeFormat;
4 |
5 | import java.util.ArrayList;
6 | import java.util.List;
7 | import java.util.Map;
8 | import org.junit.experimental.theories.PotentialAssignment;
9 | import org.slf4j.Logger;
10 | import org.slf4j.LoggerFactory;
11 |
12 | /**
13 | *
14 | * An instance of {@link BaseConverter} that is responsible for converting the raw data in to a user defined type instance
15 | * using any user defined converter
16 | *
17 | * @author Anuj Kumar
18 | *
19 | */
20 | public class UserDefinedConverter implements BaseConverter>, List> {
21 |
22 | /**
23 | * The type of parameter to convert the raw data to
24 | */
25 | private final Class parameterType;
26 |
27 | /**
28 | * The name of the parameter that is being converted
29 | */
30 | private final String paramName;
31 |
32 | /**
33 | * Whether empty values should be converted to Null values or not
34 | */
35 | private final Boolean convertEmptyToNull;
36 |
37 | /**
38 | * The user specified date time format to use
39 | */
40 | private final DateTimeFormat dateTimeFormat;
41 |
42 | /**
43 | * Logger
44 | */
45 | private static final Logger LOG = LoggerFactory.getLogger(UserDefinedConverter.class);
46 |
47 | /**
48 | *
49 | * Construct a new UserDefinedConverter
50 | * @param parameterType The type of parameter to convert the raw data to
51 | * @param paramName The name of the parameter that is being converted
52 | * @param convertEmptyToNull
53 | * @param dateTimeFormat
54 | */
55 | public UserDefinedConverter(Class parameterType, String paramName , Boolean convertEmptyToNull, DateTimeFormat dateTimeFormat) {
56 | this.parameterType = parameterType;
57 | this.paramName = paramName;
58 | this.convertEmptyToNull = convertEmptyToNull;
59 | this.dateTimeFormat = dateTimeFormat;
60 | }
61 |
62 | /**
63 | * Convert the raw data into a list of {@link PotentialAssignment} instance
64 | * that EasyTest uses to provide the right set of test data to the test method
65 | * @param convertFrom the raw data to convert from
66 | * @return the list of {@link PotentialAssignment} instances
67 | */
68 | @SuppressWarnings("unchecked")
69 | public List convert(List> convertFrom) {
70 | List potentialAssignments = null;
71 | LOG.debug("Trying to find a registerd converter for class {}", parameterType);
72 | // Try to find the Converter
73 | Converter converter = ConverterManager.findConverter(parameterType);
74 | if (converter != null) {
75 | if(converter instanceof AbstractConverter) {
76 | ConverterSupport converterSupport = new ConverterSupport();
77 | converterSupport.setConvertEmptyToNull(convertEmptyToNull);
78 | converterSupport.setDateTimeFormat(dateTimeFormat);
79 | converterSupport.setParamName(paramName);
80 | ((AbstractConverter) converter).setConverterSupport(converterSupport);
81 | }
82 |
83 | potentialAssignments = new ArrayList();
84 | LOG.debug("Converter for class {} found.", parameterType);
85 | for (Map object : convertFrom) {
86 | Object value;
87 | //TODO: This logic should be removed in future versions of EasyTest
88 | if (converter instanceof ParamAwareConverter) {
89 | value = ((ParamAwareConverter)converter).convert(object, paramName);
90 | } else {
91 | value = converter.convert(object);
92 | }
93 | potentialAssignments.add(PotentialAssignment.forValue(EMPTY_STRING, value));
94 | }
95 | }
96 | return potentialAssignments;
97 | }
98 |
99 | }
100 |
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/converter/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Package containing various data converters part of the EasyTest framework.
3 | *
4 | *
5 | */
6 |
7 | package org.easetech.easytest.converter;
--------------------------------------------------------------------------------
/src/main/java/org/easetech/easytest/exceptions/ParamAssertionError.java:
--------------------------------------------------------------------------------
1 | package org.easetech.easytest.exceptions;
2 |
3 | import java.util.Arrays;
4 | import java.util.Collection;
5 | import java.util.Iterator;
6 |
7 | /**
8 | *
9 | * An extension of {@link RuntimeException} class that handles {@link ParamAssertionError}
10 | *
11 | * @author Anuj Kumar
12 | *
13 | */
14 | public class ParamAssertionError extends RuntimeException {
15 |
16 | private static final long serialVersionUID = 1L;
17 |
18 | public ParamAssertionError(Throwable targetException,
19 | String methodName, Object... params) {
20 | super(String.format("%s(%s)", methodName, join(", ", params)),
21 | targetException);
22 | }
23 |
24 | public boolean equals(Object obj) {
25 | return toString().equals(obj.toString());
26 | }
27 |
28 | public static String join(String delimiter, Object... params) {
29 | return join(delimiter, Arrays.asList(params));
30 | }
31 |
32 | public static String join(String delimiter,
33 | Collection