@Override public void wiring() { CutDescriptor cutDescriptor = testContext.getCutDescriptor(); String testClassName = testContext.getTestClassName(); String cutClassName = cutDescriptor.getTypeName(); Collection<ParameterDescriptor> fieldDescriptors = testContext.getParamaterDescriptors().values(); fieldDescriptors.parallelStream().forEach(p -> { Optional instance = p.getInstance(); if (!instance.isPresent()) { String paramTypeName = p.getTypeName(); logger.warn("Improper wiring detected. Class under test '{}' defined " + "in '{}' declars constructor argument of type '{}' but '{}' " + "does not define a field of type '{}' annotated with @Fake.", cutClassName, testClassName, paramTypeName, testClassName, paramTypeName); } }); }
@Override public void wiring() { CutDescriptor cutDescriptor = testContext.getCutDescriptor(); String testClassName = testContext.getTestClassName(); String cutClassName = cutDescriptor.getTypeName(); Collection<ParameterDescriptor> fieldDescriptors = testContext.getParamaterDescriptors().values(); fieldDescriptors.parallelStream().forEach(p -> { Optional instance = p.getInstance(); if (!instance.isPresent()) { String paramTypeName = p.getTypeName(); logger.warn("Class under test '{}' defined in '{}' has a collaborator " + "type '{}' but test class '{}' does not define a field of " + "type '{}' annotated with @Fake. Null values will be used.", cutClassName, testClassName, paramTypeName, testClassName, paramTypeName); } }); }
public void create() { Map<DescriptorKey, ParameterDescriptor> parameterDescriptors = testContext.getParamaterDescriptors(); Map<DescriptorKey, FieldDescriptor> fieldDescriptors = testContext.getFieldDescriptors(); Object[] arguments = new Object[parameterDescriptors.size()]; Collection<FieldDescriptor> descriptors = fieldDescriptors.values(); UnitIndexFakeInjector indexInjector = new UnitIndexFakeInjector(testContext, testReifier, arguments); UnitNameFakeInjector nameInjector = new UnitNameFakeInjector(testContext, testReifier, arguments); UnitTypeFakeInjector typeInjector = new UnitTypeFakeInjector(testContext, testReifier, arguments); Set<FieldDescriptor> fakeDescriptors = descriptors.parallelStream() .filter(p -> p.hasAnnotation(Fake.class)) .collect(toSet()); //process fields with a custom index first fakeDescriptors.parallelStream() .forEach(indexInjector::inject); //process fields with custom names second fakeDescriptors.parallelStream() .forEach(nameInjector::inject); //finally process fields based on their type fakeDescriptors.parallelStream() .forEach(typeInjector::inject); testReifier.reifyCut(testContext.getCutDescriptor(), arguments); }
@Override public void wiring() { doPrivileged((PrivilegedAction<Object>) () -> { CutDescriptor cutDescriptor = testContext.getCutDescriptor(); String testClassName = testContext.getTestClassName(); Collection<ParameterDescriptor> paramDescriptors = testContext.getParamaterDescriptors().values(); if (cutDescriptor != null) { String cutClassName = cutDescriptor.getTypeName(); paramDescriptors.parallelStream().forEach(p -> { Optional instance = p.getInstance(); if (!instance.isPresent()) { String paramTypeName = p.getTypeName(); logger.warn("Improper wiring detected. Class under test '{}' defined " + "in '{}' declars constructor argument of type '{}' but '{}' " + "does not define a field of type '{}' annotated with @Fake or @Real.", cutClassName, testClassName, paramTypeName, testClassName, paramTypeName); } }); } return null; }); }
@Override public void wiring() { doPrivileged((PrivilegedAction<Object>) () -> { CutDescriptor cutDescriptor = testContext.getCutDescriptor(); String testClassName = testContext.getTestClassName(); Collection<ParameterDescriptor> paramDescriptors = testContext.getParamaterDescriptors().values(); if (cutDescriptor != null) { String cutClassName = cutDescriptor.getTypeName(); paramDescriptors.parallelStream().forEach(p -> { Optional instance = p.getInstance(); if (!instance.isPresent()) { String paramTypeName = p.getTypeName(); logger.warn("Class under test '{}' defined in '{}' has a collaborator " + "of type '{}' but test class '{}' does not define a field of " + "type '{}' annotated with @Fake, @Real, or @Inject. The real " + "instance of the collaborator will be used.", cutClassName, testClassName, paramTypeName, testClassName, paramTypeName); } }); } return null; }); }
public void create() { Map<DescriptorKey, ParameterDescriptor> parameterDescriptors = testContext.getParamaterDescriptors(); Map<DescriptorKey, FieldDescriptor> fieldDescriptors = testContext.getFieldDescriptors(); Object[] arguments = new Object[parameterDescriptors.size()]; Collection<FieldDescriptor> descriptors = fieldDescriptors.values(); UnitIndexFakeInjector indexInjector = new UnitIndexFakeInjector(testContext, testReifier, arguments); UnitNameFakeInjector nameInjector = new UnitNameFakeInjector(testContext, testReifier, arguments); UnitTypeFakeInjector typeInjector = new UnitTypeFakeInjector(testContext, testReifier, arguments); UnitServiceFakeInjector serviceInjector = new UnitServiceFakeInjector(testContext, testReifier, arguments); Set<FieldDescriptor> fakeDescriptors = descriptors.parallelStream() .filter(p -> p.hasAnnotation(Fake.class)) .collect(toSet()); //process fields with a custom index first fakeDescriptors.parallelStream() .forEach(indexInjector::inject); //process fields with custom names second fakeDescriptors.parallelStream() .forEach(nameInjector::inject); //finally process fields based on their type fakeDescriptors.parallelStream() .forEach(typeInjector::inject); testReifier.reifyCut(testContext.getCutDescriptor(), arguments); //if there are no arguments then try to inject descriptor fields. if (arguments.length == 0) { fakeDescriptors.parallelStream() .forEach(serviceInjector::inject); } }
public TestContext getTestContext(Class<?> javaClass) { String name = javaClass.getSimpleName(); TestContext testContext = testClassContexts.computeIfAbsent(javaClass, p -> { try { TestContext context = new TestContext(name, javaClass, LOGGER); ClassReader testReader = new ClassReader(javaClass.getName()); testReader.accept(new TestClassAnalyzer(context), ClassReader.SKIP_DEBUG); CutDescriptor cutDescriptor = context.getCutDescriptor(); if (cutDescriptor != null) { ClassReader cutReader = new ClassReader(context.getCutDescriptor().getField().getType().getName()); cutReader.accept(new CutClassAnalyzer(context), ClassReader.SKIP_DEBUG); } return context; } catch (Exception e) { checkState(false, "Analysis of test class '%s' failed.\n'%s'", name, e.getMessage()); //not reachable throw new IllegalStateException(e); } }); return testContext; }
@Override public void wiring() { doPrivileged((PrivilegedAction<Object>) () -> { CutDescriptor cutDescriptor = testContext.getCutDescriptor(); String testClassName = testContext.getTestClassName(); Collection<ParameterDescriptor> paramDescriptors = testContext.getParamaterDescriptors().values(); if (cutDescriptor != null) { String cutClassName = cutDescriptor.getTypeName(); paramDescriptors.parallelStream().forEach(p -> { Optional instance = p.getInstance(); if (!instance.isPresent()) { String paramTypeName = p.getTypeName(); logger.warn("Improper wiring detected. Class under test '{}' defined " + "in '{}' declars constructor argument of type '{}' but '{}' " + "does not define a field of type '{}' annotated with @Fake or @Real.", cutClassName, testClassName, paramTypeName, testClassName, paramTypeName); } }); } return null; }); }
@Override public void wiring() { doPrivileged((PrivilegedAction<Object>) () -> { CutDescriptor cutDescriptor = testContext.getCutDescriptor(); String testClassName = testContext.getTestClassName(); Collection<ParameterDescriptor> paramDescriptors = testContext.getParamaterDescriptors().values(); if (cutDescriptor != null) { String cutClassName = cutDescriptor.getTypeName(); paramDescriptors.parallelStream().forEach(p -> { Optional instance = p.getInstance(); if (!instance.isPresent()) { String paramTypeName = p.getTypeName(); logger.warn("Class under test '{}' defined in '{}' has a collaborator " + "of type '{}' but test class '{}' does not define a field of " + "type '{}' annotated with @Fake, @Real, or @Inject. The real " + "instance of the collaborator will be used.", cutClassName, testClassName, paramTypeName, testClassName, paramTypeName); } }); } return null; }); }
public TestContext getTestContext(Class<?> javaClass) { String name = javaClass.getSimpleName(); TestContext testContext = TEST_CONTEXTS.computeIfAbsent(javaClass, p -> { try { TestContext context = new TestContext(name, javaClass, LOGGER); ClassReader testReader = new ClassReader(javaClass.getName()); testReader.accept(new TestClassAnalyzer(context), ClassReader.SKIP_DEBUG); CutDescriptor cutDescriptor = context.getCutDescriptor(); if (cutDescriptor != null) { String typeName = context.getCutDescriptor().getField().getType().getName(); ClassReader cutReader = new ClassReader(typeName); cutReader.accept(new CutClassAnalyzer(context), ClassReader.SKIP_DEBUG); } return context; } catch (Exception e) { checkState(false, "Analysis of test class '%s' failed.\n'%s'", name, e.getMessage()); //not reachable throw new IllegalStateException(e); } }); return testContext; }
.forEach(realInjector::inject); testReifier.reifyCut(context.getCutDescriptor(), arguments);
public TestContext getTestContext(Class<?> javaClass) { String name = javaClass.getSimpleName(); TestContext testContext = testClassContexts.computeIfAbsent(javaClass, p -> { try { TestContext context = new TestContext(name, javaClass, LOGGER); ClassReader testReader = new ClassReader(javaClass.getName()); testReader.accept(new TestClassAnalyzer(context), ClassReader.SKIP_DEBUG); CutDescriptor cutDescriptor = context.getCutDescriptor(); if (cutDescriptor != null) { ClassReader cutReader = new ClassReader(cutDescriptor.getType().getName()); cutReader.accept(new CutClassAnalyzer(context), ClassReader.SKIP_DEBUG); } return context; } catch (Exception e) { checkState(false, "Analysis of test class '%s' failed.\n'%s'", name, e.getMessage()); //not reachable throw new IllegalStateException(e); } }); return testContext; }
@Override public void configuration() { String testClassName = testContext.getTestClassName(); Collection<FieldDescriptor> fieldDescriptors = testContext.getFieldDescriptors().values(); CutDescriptor cutDescriptor = testContext.getCutDescriptor(); checkState(testContext.getConstructorCount() == 1, "Class under test '%s' has '%d' constructors. Please insure that " + "the class under test has one and only one constructor.", cutDescriptor.getTypeName(), testContext.getConstructorCount()); fieldDescriptors.parallelStream().forEach(p -> { Class<?> fieldType = p.getType(); String fieldName = p.getName(); String fieldTypeName = p.getTypeName(); checkState(!isFinal(fieldType.getModifiers()), "Field '%s' in test class '%s' can not be mocked because '%s'" + " is a final class.", fieldName, testClassName, fieldTypeName); checkState(!p.hasAnyAnnotation(Real.class, Inject.class), "Field '%s' in test class '%s' is not annotated with @Fake. " + "Note that @Real and @Inject annotations not supported for " + "unit tests. Please use @Fake instead.", fieldName, fieldTypeName ); }); }
@Override public void inject(FieldDescriptor testFieldDescriptor) { CutDescriptor cutDescriptor = context.getCutDescriptor(); Map<DescriptorKey, FieldDescriptor> cutFieldDescriptors = cutDescriptor.getFieldDescriptors(); Type testFieldType = testFieldDescriptor.getGenericType(); String fieldName = testFieldDescriptor.getName(); DescriptorKey descriptorKey = new DescriptorKey(testFieldType, fieldName); //if there is a cut field descriptor that matches the field then lets use that if (cutFieldDescriptors.containsKey(descriptorKey)) { FieldDescriptor cutFieldDescriptor = cutFieldDescriptors.get(descriptorKey); testReifier.reifyField(cutDescriptor, cutFieldDescriptor, testFieldDescriptor); } else { //otherwise find the right field based on the type of the field Collection<FieldDescriptor> descriptors = cutFieldDescriptors.values(); for (FieldDescriptor cutFieldDEscriptor : descriptors) { Type cutFieldType = cutFieldDEscriptor.getGenericType(); TypeToken token = TypeToken.of(testFieldType); if (token.isSubtypeOf(cutFieldType)) { testReifier.reifyField(cutDescriptor, cutFieldDEscriptor, testFieldDescriptor); break; } } } }
@Override public void configuration() { String testClassName = testContext.getTestClassName(); Collection<FieldDescriptor> fieldDescriptors = testContext.getFieldDescriptors().values(); CutDescriptor cutDescriptor = testContext.getCutDescriptor(); checkState(cutDescriptor != null, "Test class '%s' does not define a field annotated with @Cut class.", testClassName); checkState(testContext.getConstructorCount() == 1, "Class under test '%s' defined in test class '%s' has %s constructors. " + "Please insure that the class under test has one and only one constructor.", cutDescriptor.getTypeName(), testClassName, testContext.getConstructorCount()); fieldDescriptors.parallelStream().forEach(p -> { Class<?> fieldType = p.getType(); String fieldName = p.getName(); String fieldTypeName = p.getTypeName(); checkState(!isFinal(fieldType.getModifiers()), "Field '%s' in test class '%s' can not be faked because '%s'" + " is a final class.", fieldName, testClassName, fieldTypeName); checkState(!p.hasAnyAnnotation(Real.class, Inject.class), "Field '%s' in test class '%s' is annotated with @Real or @Inject. " + "@Real and @Inject annotations are not supported for unit tests. " + "Please use @Fake instead.", fieldName, testClassName ); }); }
= new SystemTestCreator(testContext, reifier, serviceLocator); if (testContext.getCutDescriptor() != null) { creator.cut();
String fieldName = descriptor.getName(); String fieldTypeName = descriptor.getTypeName(); String cutTypeName = context.getCutDescriptor().getTypeName(); String testClassName = context.getTestClassName();
String fieldTypeName = descriptor.getTypeName(); String fieldName = descriptor.getName(); String cutTypeName = context.getCutDescriptor().getTypeName();
String fieldTypeName = descriptor.getTypeName(); String fieldName = descriptor.getName(); String cutTypeName = context.getCutDescriptor().getTypeName();
String fieldTypeName = descriptor.getTypeName(); String fieldName = descriptor.getName(); String cutTypeName = context.getCutDescriptor().getTypeName();