public PetiteResolvers(final ReferencesResolver referencesResolver) { this.referencesResolver = referencesResolver; this.ctorResolver = new CtorResolver(referencesResolver); this.methodResolver = new MethodResolver(referencesResolver); this.propertyResolver = new PropertyResolver(referencesResolver); this.setResolver = new SetResolver(); this.initMethodResolver = new InitMethodResolver(); this.destroyMethodResolver = new DestroyMethodResolver(); this.providerResolver = new ProviderResolver(); }
/** * Resolves method injection points. */ public MethodInjectionPoint[] resolveMethodInjectionPoint(final Class type) { return methodResolver.resolve(type); }
/** * Resolves set injection points. */ public SetInjectionPoint[] resolveSetInjectionPoint(final Class type, final boolean autowire) { return setResolver.resolve(type, autowire); }
@Test void testNoAnnotation() { Arrays.asList( method(Revolver.class, "noAnnotation"), ctor(Revolver.NoAnnotation.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.readAllReferencesFromAnnotation(method(Revolver.class, "noAnnotation")); assertEquals(null, refs); }); }
@Test void testResolveReferenceFromValues_invalidNumberOfRefs() { Arrays.asList( method(Revolver.class, "someArguments"), ctor(Revolver.SomeArguments.class) ).forEach(methodOrCtor -> { assertThrows(PetiteException.class, () -> { referencesResolver.resolveReferenceFromValues(methodOrCtor, "i1"); }); }); }
@Test void testFieldAnnotation_nothing() { BeanReferences refs = referencesResolver.readReferenceFromAnnotation(field(Revolver.class, "nothing")); assertEquals(null, refs); }
/** * Resolves constructor injection point. */ public CtorInjectionPoint resolveCtorInjectionPoint(final Class type) { return ctorResolver.resolve(type, true); }
/** * Resolves property injection points. */ public PropertyInjectionPoint[] resolvePropertyInjectionPoint(final Class type, final boolean autowire) { return propertyResolver.resolve(type, autowire); }
/** * Resolves init method points. */ public InitMethodPoint[] resolveInitMethodPoint(final Class type) { return initMethodResolver.resolve(type); }
private BeanReferences updateReferencesWithDefaultsIfNeeded(final PropertyDescriptor propertyDescriptor, BeanReferences references) { if (references == null || references.isEmpty()) { references = buildDefaultReference(propertyDescriptor); } return references; }
/** * Resolves provider definition defined in a bean. */ public ProviderDefinition[] resolveProviderDefinitions(final Class type, final String name) { return providerResolver.resolve(type, name); }
/** * Resolves destroy method points. */ public DestroyMethodPoint[] resolveDestroyMethodPoint(final Class type) { return destroyMethodResolver.resolve(type); }
@Test void testAnnotation_noArguments() { Arrays.asList( method(Revolver.class, "onlyAnnotation"), ctor(Revolver.OnlyAnnotation.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.readAllReferencesFromAnnotation(methodOrCtor); assertEquals(0, refs.length); }); }
@Test void testResolveReferenceFromValues_explicit() { Arrays.asList( method(Revolver.class, "someArguments"), ctor(Revolver.SomeArguments.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.resolveReferenceFromValues(methodOrCtor, "i1", "i2"); assertEquals(2, refs.length); assertEquals(1, refs[0].size()); assertEquals("i1", refs[0].name(0)); assertEquals(1, refs[1].size()); assertEquals("i2", refs[1].name(0)); }); }
@Test void testFieldAnnotation_withValue() { BeanReferences refs = referencesResolver.readReferenceFromAnnotation(field(Revolver.class, "valued")); assertEquals(1, refs.size()); assertEquals("inn", refs.name(0)); } @Test
/** * Resolves reference from given values. Returns bean reference of given value or defaults * if given name is blank. */ public BeanReferences resolveReferenceFromValue(final PropertyDescriptor propertyDescriptor, final String refName) { BeanReferences references; if (refName == null || refName.isEmpty()) { references = buildDefaultReference(propertyDescriptor); } else { references = BeanReferences.of(refName); } references = references.removeDuplicateNames(); return references; }
@Test void testAnnotation_withWrongValue() { Arrays.asList( method(Revolver.class, "someArguments_wrongAnnotation"), ctor(Revolver.SomeArguments_wrongAnnotation.class) ).forEach(methodOrCtor -> { assertThrows(PetiteException.class, () -> referencesResolver.readAllReferencesFromAnnotation(methodOrCtor)); }); }
@Test void testFieldAnnotation_annotation() { BeanReferences refs = referencesResolver.readReferenceFromAnnotation(field(Revolver.class, "onlyAnnotation")); assertEquals(3, refs.size()); assertEquals("onlyAnnotation", refs.name(0)); assertEquals("string", refs.name(1)); assertEquals("java.lang.String", refs.name(2)); } @Test
@Test void testAnnotation_mix() { Arrays.asList( method(Revolver.class, "mix"), ctor(Revolver.Mix.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.readAllReferencesFromAnnotation(methodOrCtor); assertEquals(2, refs.length); assertEquals(1, refs[0].size()); assertEquals("innn1", refs[0].name(0)); assertEquals(1, refs[1].size()); assertEquals("bbbb", refs[1].name(0)); }); }
@Test void testAnnotation_withCsvValue() { Arrays.asList( method(Revolver.class, "someArguments_csv"), ctor(Revolver.SomeArguments_csv.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.readAllReferencesFromAnnotation(methodOrCtor); assertEquals(2, refs.length); assertEquals(1, refs[0].size()); assertEquals("innn1", refs[0].name(0)); assertEquals(1, refs[1].size()); assertEquals("innn2", refs[1].name(0)); }); }