io.github.glytching.junit.extension.random.RandomBeansExtension - Code Metrics - glytching/junit-extensions - Measure and Improve Code Quality continuously with Scrutinizer

io.github.glytching.junit.extension.random.RandomBeansExtension A
last analyzed 2022-08-12 09:31 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	134
rs	10
c	1
b	0
f	0
eloc	49
wmc	14

6 Methods

Rating	Name	Size	Complexity
A	supportsParameter(ParameterContext,ExtensionContext)	5	1
A	resolveParameter(ParameterContext,ExtensionContext)	7	1
A	RandomBeansExtension(EnhancedRandom)	2	1
A	resolve(Class,Random)	13	5
A	postProcessTestInstance(Object,ExtensionContext)	11	5
A	RandomBeansExtension()	27	1

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 io.github.glytching.junit.extension.random;

import io.github.benas.randombeans.EnhancedRandomBuilder;
import io.github.benas.randombeans.api.EnhancedRandom;
import org.junit.jupiter.api.extension.*;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static java.nio.charset.Charset.forName;
import static org.junit.platform.commons.support.AnnotationSupport.isAnnotated;

/**
 * The random beans extension provides a test with randomly generated objects, including:
 *
 * <ul>
 *   <li>JDK types
 *   <li>Custom types
 *   <li>Collections
 *   <li>Generic collections
 *   <li>Partial population
 * </ul>
 *
 * <p>Usage examples:
 *
 * <p>Injecting random values as fields:
 *
 * <pre>
 * &#064;ExtendWith(RandomBeansExtension.class)
 * public class MyTest {
 *
 *     &#064;Random
 *     private String anyString;
 *
 *     &#064;Random(excluded = {"name", "value"})
 *     private List<DomainObject> anyPartiallyPopulatedDomainObject;
 *
 *     &#064;Random(type = DomainObject.class)
 *     private List<DomainObject> anyDomainObjects;
 *
 *     &#064;Test
 *     public void testUsingRandomString() {
 *         // use the injected anyString
 *         // ...
 *     }
 *
 *     &#064;Test
 *     public void testUsingRandomDomainObjects() {
 *         // use the injected anyDomainObjects
 *         // the anyDomainObjects will contain _N_ fully populated random instances of DomainObject
 *         // ...
 *     }
 *
 *     &#064;Test
 *     public void testUsingPartiallyPopulatedDomainObject() {
 *         // use the injected anyPartiallyPopulatedDomainObject
 *         // this object's "name" and "value" members will not be populated since this has been declared with
 *         //     excluded = {"name", "value"}
 *         // ...
 *     }
 * }
 * </pre>
 *
 * <p>Injecting random values as parameters:
 *
 * <pre>
 * &#064;ExtendWith(RandomBeansExtension.class)
 * public class MyTest {
 *
 *     &#064;Test
 *     &#064;ExtendWith(RandomBeansExtension.class)
 *     public void testUsingRandomString(&#064;Random String anyString) {
 *         // use the provided anyString
 *         // ...
 *     }
 *
 *     &#064;Test
 *     &#064;ExtendWith(RandomBeansExtension.class)
 *     public void testUsingRandomDomainObjects(&#064;Random(type = DomainObject.class) List<DomainObject> anyDomainObjects) {
 *         // use the injected anyDomainObjects
 *         // the anyDomainObjects will contain _N_ fully populated random instances of DomainObject
 *         // ...
 *     }
 *
 *     &#064;Test
 *     &#064;ExtendWith(RandomBeansExtension.class)
 *     public void testUsingPartiallyPopulatedDomainObject(&#064;Random(excluded = {"name", "value"}) List<DomainObject> anyPartiallyPopulatedDomainObject) {
 *         // use the injected anyPartiallyPopulatedDomainObject
 *         // this object's "name" and "value" members will not be populated since this has been declared with
 *         //     excluded = {"name", "value"}
 *         // ...
 *     }
 * }
 * </pre>
 *
 * @see <a href="https://github.com/benas/random-beans">Random Beans</a>
 * @since 1.0.0
 */
public class RandomBeansExtension implements TestInstancePostProcessor, ParameterResolver {

  private final EnhancedRandom random;

  /**
   * Create the extension with a default {@link EnhancedRandom}.
   *
   * @see <a href="https://github.com/benas/random-beans/wiki/Randomization-parameters">Enhanced
   *     Random Configuration Parameters</a>
   */
  public RandomBeansExtension() {
    this(EnhancedRandomBuilder.aNewEnhancedRandomBuilder()
            // maximum number of instances of a given type, above this number requests will start to
            // reuse
            // previously generated instances
            .objectPoolSize(10)

            // how deep should we go when randomising an object graph?
            .randomizationDepth(5)

            // the charset used for all String and Character values
            .charset(forName("UTF-8"))

            // min, max bounds for the generated string length
            .stringLengthRange(5, 50)

            // min, max bounds for the generated collections size
            .collectionSizeRange(1, 10)

            // if a random values is declared as an abstract or interface type then the classpath
            // will be scanned
            // for a concrete type of that abstract or interface type
            .scanClasspathForConcreteTypes(true)

            // do not override any values which are already initialised in the target type
            .overrideDefaultInitialization(false)
            .build());
  }

  /**
   * Create the extension with the given {@link EnhancedRandom}. This is used, instead of the zero-arg alternative, when
   * the caller wants to override the default 'randomizer' configuration. This constructor will be called by using the
   * {@code RegisterExtension} annotation.
   *
   * @param enhancedRandom
   * @since 2.5.0
   */
  public RandomBeansExtension(EnhancedRandom enhancedRandom) {
    this.random = enhancedRandom;

  }

  /**
   * Does this extension support injection for parameters of the type described by the given {@code
   * parameterContext}?
   *
   * @param parameterContext the context for the parameter for which an argument should be resolved
   * @param extensionContext the extension context for the {@code Executable} about to be invoked
   * @return true if the given {@code parameterContext} is annotated with {@link Random}, false
   *     otherwise
   * @throws ParameterResolutionException
   */
  @Override
  public boolean supportsParameter(
      ParameterContext parameterContext, ExtensionContext extensionContext)
      throws ParameterResolutionException {
    return parameterContext.getParameter().getAnnotation(Random.class) != null;
  }

  /**
   * Provides a value for any parameter context which has passed the {@link
   * #supportsParameter(ParameterContext, ExtensionContext)} gate.
   *
   * @param parameterContext the context for the parameter for which an argument should be resolved
   * @param extensionContext the <em>context</em> in which the current test or container is being
   *     executed
   * @return a randomly generated object
   * @throws ParameterResolutionException
   */
  @Override
  public Object resolveParameter(
      ParameterContext parameterContext, ExtensionContext extensionContext)
      throws ParameterResolutionException {
    return resolve(
        parameterContext.getParameter().getType(),
        parameterContext.getParameter().getAnnotation(Random.class));
  }

  /**
   * Inject random values into any fields which are annotated with {@link Random}. 
   * This method doesn't populate static fields if they have values.
   *
   * @param testInstance the instance to post-process
   * @param extensionContext the current extension context
   * @throws Exception
   */
  @Override
  public void postProcessTestInstance(Object testInstance, ExtensionContext extensionContext)
      throws Exception {
    for (Field field : testInstance.getClass().getDeclaredFields()) {
      if (isAnnotated(field, Random.class)) {
        Random annotation = field.getAnnotation(Random.class);
        Object randomObject = resolve(field.getType(), annotation);
        
        field.setAccessible(true);
        if (!Modifier.isStatic(field.getModifiers()) || field.get(testInstance) == null) {
          field.set(testInstance, randomObject);
        }
      }
    }
  }

  /**
   * Maps the 'random requirements' expressed by the given {@code annotation} to invocations on
   * {@link #random}.
   *
   * @param targetType the type to be provided
   * @param annotation an instance of {@link Random} which describes how the user wishes to
   *     configure the 'random generation'
   * @return a randomly generated instance of {@code targetType}
   */
  private Object resolve(Class<?> targetType, Random annotation) {
    if (targetType.isAssignableFrom(List.class) || targetType.isAssignableFrom(Collection.class)) {
      return random
          .objects(annotation.type(), annotation.size(), annotation.excludes())
          .collect(Collectors.toList());
    } else if (targetType.isAssignableFrom(Set.class)) {
      return random
          .objects(annotation.type(), annotation.size(), annotation.excludes())
          .collect(Collectors.toSet());
    } else if (targetType.isAssignableFrom(Stream.class)) {
      return random.objects(annotation.type(), annotation.size(), annotation.excludes());
    } else {
      return random.nextObject(targetType, annotation.excludes());
    }
  }

}


1			/*
2			* Licensed to the Apache Software Foundation (ASF) under one or more
3			* contributor license agreements. See the NOTICE file distributed with
4			* this work for additional information regarding copyright ownership.
5			* The ASF licenses this file to You under the Apache License, Version 2.0
6			* (the "License"); you may not use this file except in compliance with
7			* the License. You may obtain a copy of the License at
8			*
9			* http://www.apache.org/licenses/LICENSE-2.0
10			*
11			* Unless required by applicable law or agreed to in writing, software
12			* distributed under the License is distributed on an "AS IS" BASIS,
13			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14			* See the License for the specific language governing permissions and
15			* limitations under the License.
16			*/
17			package io.github.glytching.junit.extension.random;
18
19			import io.github.benas.randombeans.EnhancedRandomBuilder;
20			import io.github.benas.randombeans.api.EnhancedRandom;
21			import org.junit.jupiter.api.extension.*;
22
23			import java.lang.reflect.Field;
24			import java.lang.reflect.Modifier;
25			import java.util.Collection;
26			import java.util.List;
27			import java.util.Set;
28			import java.util.stream.Collectors;
29			import java.util.stream.Stream;
30
31			import static java.nio.charset.Charset.forName;
32			import static org.junit.platform.commons.support.AnnotationSupport.isAnnotated;
33
34			/**
35			* The random beans extension provides a test with randomly generated objects, including:
36			*
37			* <ul>
38			* <li>JDK types
39			* <li>Custom types
40			* <li>Collections
41			* <li>Generic collections
42			* <li>Partial population
43			* </ul>
44			*
45			* <p>Usage examples:
46			*
47			* <p>Injecting random values as fields:
48			*
49			* <pre>
50			* @ExtendWith(RandomBeansExtension.class)
51			* public class MyTest {
52			*
53			* @Random
54			* private String anyString;
55			*
56			* @Random(excluded = {"name", "value"})
57			* private List<DomainObject> anyPartiallyPopulatedDomainObject;
58			*
59			* @Random(type = DomainObject.class)
60			* private List<DomainObject> anyDomainObjects;
61			*
62			* @Test
63			* public void testUsingRandomString() {
64			* // use the injected anyString
65			* // ...
66			* }
67			*
68			* @Test
69			* public void testUsingRandomDomainObjects() {
70			* // use the injected anyDomainObjects
71			* // the anyDomainObjects will contain _N_ fully populated random instances of DomainObject
72			* // ...
73			* }
74			*
75			* @Test
76			* public void testUsingPartiallyPopulatedDomainObject() {
77			* // use the injected anyPartiallyPopulatedDomainObject
78			* // this object's "name" and "value" members will not be populated since this has been declared with
79			* // excluded = {"name", "value"}
80			* // ...
81			* }
82			* }
83			* </pre>
84			*
85			* <p>Injecting random values as parameters:
86			*
87			* <pre>
88			* @ExtendWith(RandomBeansExtension.class)
89			* public class MyTest {
90			*
91			* @Test
92			* @ExtendWith(RandomBeansExtension.class)
93			* public void testUsingRandomString(@Random String anyString) {
94			* // use the provided anyString
95			* // ...
96			* }
97			*
98			* @Test
99			* @ExtendWith(RandomBeansExtension.class)
100			* public void testUsingRandomDomainObjects(@Random(type = DomainObject.class) List<DomainObject> anyDomainObjects) {
101			* // use the injected anyDomainObjects
102			* // the anyDomainObjects will contain _N_ fully populated random instances of DomainObject
103			* // ...
104			* }
105			*
106			* @Test
107			* @ExtendWith(RandomBeansExtension.class)
108			* public void testUsingPartiallyPopulatedDomainObject(@Random(excluded = {"name", "value"}) List<DomainObject> anyPartiallyPopulatedDomainObject) {
109			* // use the injected anyPartiallyPopulatedDomainObject
110			* // this object's "name" and "value" members will not be populated since this has been declared with
111			* // excluded = {"name", "value"}
112			* // ...
113			* }
114			* }
115			* </pre>
116			*
117			* @see <a href="https://github.com/benas/random-beans">Random Beans</a>
118			* @since 1.0.0
119			*/
120			public class RandomBeansExtension implements TestInstancePostProcessor, ParameterResolver {
121
122			private final EnhancedRandom random;
123
124			/**
125			* Create the extension with a default {@link EnhancedRandom}.
126			*
127			* @see <a href="https://github.com/benas/random-beans/wiki/Randomization-parameters">Enhanced
128			* Random Configuration Parameters</a>
129			*/
130			public RandomBeansExtension() {
131			this(EnhancedRandomBuilder.aNewEnhancedRandomBuilder()
132			// maximum number of instances of a given type, above this number requests will start to
133			// reuse
134			// previously generated instances
135			.objectPoolSize(10)
136
137			// how deep should we go when randomising an object graph?
138			.randomizationDepth(5)
139
140			// the charset used for all String and Character values
141			.charset(forName("UTF-8"))
142
143			// min, max bounds for the generated string length
144			.stringLengthRange(5, 50)
145
146			// min, max bounds for the generated collections size
147			.collectionSizeRange(1, 10)
148
149			// if a random values is declared as an abstract or interface type then the classpath
150			// will be scanned
151			// for a concrete type of that abstract or interface type
152			.scanClasspathForConcreteTypes(true)
153
154			// do not override any values which are already initialised in the target type
155			.overrideDefaultInitialization(false)
156			.build());
157			}
158
159			/**
160			* Create the extension with the given {@link EnhancedRandom}. This is used, instead of the zero-arg alternative, when
161			* the caller wants to override the default 'randomizer' configuration. This constructor will be called by using the
162			* {@code RegisterExtension} annotation.
163			*
164			* @param enhancedRandom
165			* @since 2.5.0
166			*/
167			public RandomBeansExtension(EnhancedRandom enhancedRandom) {
168			this.random = enhancedRandom;
169
170			}
171
172			/**
173			* Does this extension support injection for parameters of the type described by the given {@code
174			* parameterContext}?
175			*
176			* @param parameterContext the context for the parameter for which an argument should be resolved
177			* @param extensionContext the extension context for the {@code Executable} about to be invoked
178			* @return true if the given {@code parameterContext} is annotated with {@link Random}, false
179			* otherwise
180			* @throws ParameterResolutionException
181			*/
182			@Override
183			public boolean supportsParameter(
184			ParameterContext parameterContext, ExtensionContext extensionContext)
185			throws ParameterResolutionException {
186			return parameterContext.getParameter().getAnnotation(Random.class) != null;
187			}
188
189			/**
190			* Provides a value for any parameter context which has passed the {@link
191			* #supportsParameter(ParameterContext, ExtensionContext)} gate.
192			*
193			* @param parameterContext the context for the parameter for which an argument should be resolved
194			* @param extensionContext the <em>context</em> in which the current test or container is being
195			* executed
196			* @return a randomly generated object
197			* @throws ParameterResolutionException
198			*/
199			@Override
200			public Object resolveParameter(
201			ParameterContext parameterContext, ExtensionContext extensionContext)
202			throws ParameterResolutionException {
203			return resolve(
204			parameterContext.getParameter().getType(),
205			parameterContext.getParameter().getAnnotation(Random.class));
206			}
207
208			/**
209			* Inject random values into any fields which are annotated with {@link Random}.
210			* This method doesn't populate static fields if they have values.
211			*
212			* @param testInstance the instance to post-process
213			* @param extensionContext the current extension context
214			* @throws Exception
215			*/
216			@Override
217			public void postProcessTestInstance(Object testInstance, ExtensionContext extensionContext)
218			throws Exception {
219			for (Field field : testInstance.getClass().getDeclaredFields()) {
220			if (isAnnotated(field, Random.class)) {
221			Random annotation = field.getAnnotation(Random.class);
222			Object randomObject = resolve(field.getType(), annotation);
223
224			field.setAccessible(true);
225			if (!Modifier.isStatic(field.getModifiers()) \|\| field.get(testInstance) == null) {
226			field.set(testInstance, randomObject);
227			}
228			}
229			}
230			}
231
232			/**
233			* Maps the 'random requirements' expressed by the given {@code annotation} to invocations on
234			* {@link #random}.
235			*
236			* @param targetType the type to be provided
237			* @param annotation an instance of {@link Random} which describes how the user wishes to
238			* configure the 'random generation'
239			* @return a randomly generated instance of {@code targetType}
240			*/
241			private Object resolve(Class<?> targetType, Random annotation) {
242			if (targetType.isAssignableFrom(List.class) \|\| targetType.isAssignableFrom(Collection.class)) {
243			return random
244			.objects(annotation.type(), annotation.size(), annotation.excludes())
245			.collect(Collectors.toList());
246			} else if (targetType.isAssignableFrom(Set.class)) {
247			return random
248			.objects(annotation.type(), annotation.size(), annotation.excludes())
249			.collect(Collectors.toSet());
250			} else if (targetType.isAssignableFrom(Stream.class)) {
251			return random.objects(annotation.type(), annotation.size(), annotation.excludes());
252			} else {
253			return random.nextObject(targetType, annotation.excludes());
254			}
255			}
256
257			}
258

glytching / junit-extensions

GitHub Access Token became invalid

io.github.glytching.junit.extension.random.RandomBeansExtension A last analyzed 2022-08-12 09:31 UTC

Complexity

Size/Duplication

Importance

6 Methods

Duplication Side-by-Side

Filter issues like

io.github.glytching.junit.extension.random.RandomBeansExtension A
last analyzed 2022-08-12 09:31 UTC