You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@isis.apache.org by da...@apache.org on 2015/01/22 16:22:18 UTC
[1/2] isis git commit: ISIS-970: unit testing @Property annotation
Repository: isis
Updated Branches:
refs/heads/ISIS-970 97c1e3def -> c459aa5e8
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactoryTest.java b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactoryTest.java
new file mode 100644
index 0000000..5d1a325
--- /dev/null
+++ b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactoryTest.java
@@ -0,0 +1,759 @@
+package org.apache.isis.core.metamodel.facets.properties.property;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.regex.Pattern;
+import org.jmock.Expectations;
+import org.jmock.auto.Mock;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.apache.isis.applib.Identifier;
+import org.apache.isis.applib.annotation.Optionality;
+import org.apache.isis.applib.annotation.PostsPropertyChangedEvent;
+import org.apache.isis.applib.annotation.Property;
+import org.apache.isis.applib.annotation.PropertyInteraction;
+import org.apache.isis.applib.annotation.When;
+import org.apache.isis.applib.annotation.Where;
+import org.apache.isis.applib.services.eventbus.PropertyChangedEvent;
+import org.apache.isis.applib.services.eventbus.PropertyDomainEvent;
+import org.apache.isis.applib.services.eventbus.PropertyInteractionEvent;
+import org.apache.isis.applib.spec.Specification;
+import org.apache.isis.core.metamodel.adapter.ObjectAdapter;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facetapi.FacetHolder;
+import org.apache.isis.core.metamodel.facetapi.FacetUtil;
+import org.apache.isis.core.metamodel.facets.AbstractFacetFactoryJUnit4TestCase;
+import org.apache.isis.core.metamodel.facets.FacetFactory;
+import org.apache.isis.core.metamodel.facets.all.hide.HiddenFacet;
+import org.apache.isis.core.metamodel.facets.members.disabled.DisabledFacet;
+import org.apache.isis.core.metamodel.facets.object.regex.RegExFacet;
+import org.apache.isis.core.metamodel.facets.propcoll.accessor.PropertyOrCollectionAccessorFacetAbstract;
+import org.apache.isis.core.metamodel.facets.propcoll.notpersisted.NotPersistedFacet;
+import org.apache.isis.core.metamodel.facets.properties.property.disabled.DisabledFacetForPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.hidden.HiddenFacetForPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.mandatory.MandatoryFacetForPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.maxlength.MaxLengthFacetForPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertyClearFacetForDomainEventFromDefault;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertyClearFacetForDomainEventFromPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertyClearFacetForDomainEventFromPropertyInteractionAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertyClearFacetForPostsPropertyChangedEventAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertyDomainEventFacet;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertyDomainEventFacetDefault;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertyDomainEventFacetForPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertyDomainEventFacetForPropertyInteractionAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertySetterFacetForDomainEventFromDefault;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertySetterFacetForDomainEventFromPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertySetterFacetForDomainEventFromPropertyInteractionAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.modify.PropertySetterFacetForPostsPropertyChangedEventAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.mustsatisfy.MustSatisfySpecificationFacetForPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.notpersisted.NotPersistedFacetForPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.property.regex.RegExFacetForPropertyAnnotation;
+import org.apache.isis.core.metamodel.facets.properties.update.clear.PropertyClearFacet;
+import org.apache.isis.core.metamodel.facets.properties.update.clear.PropertyClearFacetAbstract;
+import org.apache.isis.core.metamodel.facets.properties.update.modify.PropertySetterFacet;
+import org.apache.isis.core.metamodel.facets.properties.update.modify.PropertySetterFacetAbstract;
+import org.apache.isis.core.metamodel.facets.propparam.mandatory.MandatoryFacet;
+import org.apache.isis.core.metamodel.facets.propparam.maxlen.MaxLengthFacet;
+import org.apache.isis.core.metamodel.facets.propparam.mustsatisfyspec.MustSatisfySpecificationFacet;
+import org.apache.isis.core.metamodel.spec.ObjectSpecification;
+
+import static org.apache.isis.core.commons.matchers.IsisMatchers.classEqualTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+public class PropertyAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4TestCase {
+
+ PropertyAnnotationFacetFactory facetFactory;
+ Method propertyMethod;
+
+ @Mock
+ ObjectSpecification mockTypeSpec;
+ @Mock
+ ObjectSpecification mockReturnTypeSpec;
+
+ void expectRemoveMethod(final Method actionMethod) {
+ context.checking(new Expectations() {{
+ oneOf(mockMethodRemover).removeMethod(actionMethod);
+ }});
+ }
+
+ void allowingLoadSpecificationRequestsFor(final Class<?> cls, final Class<?> returnType) {
+ context.checking(new Expectations() {{
+ allowing(mockSpecificationLoaderSpi).loadSpecification(cls);
+ will(returnValue(mockTypeSpec));
+
+ allowing(mockSpecificationLoaderSpi).loadSpecification(returnType);
+ will(returnValue(mockReturnTypeSpec));
+ }});
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ facetFactory = new PropertyAnnotationFacetFactory();
+ facetFactory.setSpecificationLookup(mockSpecificationLoaderSpi);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ facetFactory = null;
+ }
+
+ public static class Modify extends PropertyAnnotationFacetFactoryTest {
+
+ private void addGetterFacet(final FacetHolder holder) {
+ FacetUtil.addFacet(new PropertyOrCollectionAccessorFacetAbstract(holder) {
+ @Override
+ public Object getProperty(final ObjectAdapter inObject) {
+ return null;
+ }
+ });
+ }
+
+ private void addSetterFacet(final FacetHolder holder) {
+ FacetUtil.addFacet(new PropertySetterFacetAbstract(holder) {
+ @Override
+ public void setProperty(final ObjectAdapter inObject, final ObjectAdapter value) {
+ }
+ });
+ }
+
+ private void addClearFacet(final FacetHolder holder) {
+ FacetUtil.addFacet(new PropertyClearFacetAbstract(holder) {
+ @Override
+ public void clearProperty(final ObjectAdapter inObject) {
+ }
+ });
+ }
+
+
+ @Test
+ public void withDeprecatedPostsPropertyChangedEvent_andGetterFacet_andSetterFacet() {
+
+ class Customer {
+ class NamedChanged extends PropertyChangedEvent<Customer, String> {
+ public NamedChanged(final Customer source, final String oldValue, final String newValue) {
+ super(source, oldValue, newValue);
+ }
+ }
+ @PostsPropertyChangedEvent(Customer.NamedChanged.class)
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ addGetterFacet(facetedMethod);
+ addSetterFacet(facetedMethod);
+ addClearFacet(facetedMethod);
+
+ // expect
+ allowingLoadSpecificationRequestsFor(cls, propertyMethod.getReturnType());
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processModify(processMethodContext);
+
+ // then
+ final Facet domainEventFacet = facetedMethod.getFacet(PropertyDomainEventFacet.class);
+ Assert.assertNotNull(domainEventFacet);
+ Assert.assertTrue(domainEventFacet instanceof PropertyDomainEventFacetDefault); // this is discarded at runtime, see PropertySetterFacetForPostsPropertyChangedEventAnnotation#verify(...)
+
+ // then
+ final Facet setterFacet = facetedMethod.getFacet(PropertySetterFacet.class);
+ Assert.assertNotNull(setterFacet);
+ Assert.assertTrue(setterFacet instanceof PropertySetterFacetForPostsPropertyChangedEventAnnotation);
+ PropertySetterFacetForPostsPropertyChangedEventAnnotation setterFacetImpl = (PropertySetterFacetForPostsPropertyChangedEventAnnotation) setterFacet;
+ assertThat(setterFacetImpl.value(), classEqualTo(Customer.NamedChanged.class));
+
+ // then
+ final Facet clearFacet = facetedMethod.getFacet(PropertyClearFacet.class);
+ Assert.assertNotNull(clearFacet);
+ Assert.assertTrue(clearFacet instanceof PropertyClearFacetForPostsPropertyChangedEventAnnotation);
+ PropertyClearFacetForPostsPropertyChangedEventAnnotation clearFacetImpl = (PropertyClearFacetForPostsPropertyChangedEventAnnotation) clearFacet;
+ assertThat(clearFacetImpl.value(), classEqualTo(Customer.NamedChanged.class));
+ }
+
+
+ @Test
+ public void withPropertyInteractionEvent() {
+
+ class Customer {
+ class NamedChanged extends PropertyInteractionEvent<Customer, String> {
+ public NamedChanged(final Customer source, final Identifier identifier, final String oldValue, final String newValue) {
+ super(source, identifier, oldValue, newValue);
+ }
+ }
+ @PropertyInteraction(Customer.NamedChanged.class)
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ addGetterFacet(facetedMethod);
+ addSetterFacet(facetedMethod);
+ addClearFacet(facetedMethod);
+
+ // expect
+ allowingLoadSpecificationRequestsFor(cls, propertyMethod.getReturnType());
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processModify(processMethodContext);
+
+ // then
+ final Facet domainEventFacet = facetedMethod.getFacet(PropertyDomainEventFacet.class);
+ Assert.assertNotNull(domainEventFacet);
+ Assert.assertTrue(domainEventFacet instanceof PropertyDomainEventFacetForPropertyInteractionAnnotation);
+ PropertyDomainEventFacetForPropertyInteractionAnnotation domainEventFacetImpl = (PropertyDomainEventFacetForPropertyInteractionAnnotation) domainEventFacet;
+ assertThat(domainEventFacetImpl.value(), classEqualTo(Customer.NamedChanged.class));
+
+ // then
+ final Facet setterFacet = facetedMethod.getFacet(PropertySetterFacet.class);
+ Assert.assertNotNull(setterFacet);
+ Assert.assertTrue(setterFacet instanceof PropertySetterFacetForDomainEventFromPropertyInteractionAnnotation);
+ PropertySetterFacetForDomainEventFromPropertyInteractionAnnotation setterFacetImpl = (PropertySetterFacetForDomainEventFromPropertyInteractionAnnotation) setterFacet;
+ assertThat(setterFacetImpl.value(), classEqualTo(Customer.NamedChanged.class));
+
+ // then
+ final Facet clearFacet = facetedMethod.getFacet(PropertyClearFacet.class);
+ Assert.assertNotNull(clearFacet);
+ Assert.assertTrue(clearFacet instanceof PropertyClearFacetForDomainEventFromPropertyInteractionAnnotation);
+ PropertyClearFacetForDomainEventFromPropertyInteractionAnnotation clearFacetImpl = (PropertyClearFacetForDomainEventFromPropertyInteractionAnnotation) clearFacet;
+ assertThat(clearFacetImpl.value(), classEqualTo(Customer.NamedChanged.class));
+ }
+
+ @Test
+ public void withPropertyDomainEvent() {
+
+ class Customer {
+ class NamedChanged extends PropertyDomainEvent<Customer, String> {
+ public NamedChanged(final Customer source, final Identifier identifier, final String oldValue, final String newValue) {
+ super(source, identifier, oldValue, newValue);
+ }
+ }
+ @Property(domainEvent=Customer.NamedChanged.class)
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ addGetterFacet(facetedMethod);
+ addSetterFacet(facetedMethod);
+ addClearFacet(facetedMethod);
+
+ // expect
+ allowingLoadSpecificationRequestsFor(cls, propertyMethod.getReturnType());
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processModify(processMethodContext);
+
+ // then
+ final Facet domainEventFacet = facetedMethod.getFacet(PropertyDomainEventFacet.class);
+ Assert.assertNotNull(domainEventFacet);
+ Assert.assertTrue(domainEventFacet instanceof PropertyDomainEventFacetForPropertyAnnotation);
+ PropertyDomainEventFacetForPropertyAnnotation domainEventFacetImpl = (PropertyDomainEventFacetForPropertyAnnotation) domainEventFacet;
+ assertThat(domainEventFacetImpl.value(), classEqualTo(Customer.NamedChanged.class));
+
+ // then
+ final Facet setterFacet = facetedMethod.getFacet(PropertySetterFacet.class);
+ Assert.assertNotNull(setterFacet);
+ Assert.assertTrue(setterFacet instanceof PropertySetterFacetForDomainEventFromPropertyAnnotation);
+ PropertySetterFacetForDomainEventFromPropertyAnnotation setterFacetImpl = (PropertySetterFacetForDomainEventFromPropertyAnnotation) setterFacet;
+ assertThat(setterFacetImpl.value(), classEqualTo(Customer.NamedChanged.class));
+
+ // then
+ final Facet clearFacet = facetedMethod.getFacet(PropertyClearFacet.class);
+ Assert.assertNotNull(clearFacet);
+ Assert.assertTrue(clearFacet instanceof PropertyClearFacetForDomainEventFromPropertyAnnotation);
+ PropertyClearFacetForDomainEventFromPropertyAnnotation clearFacetImpl = (PropertyClearFacetForDomainEventFromPropertyAnnotation) clearFacet;
+ assertThat(clearFacetImpl.value(), classEqualTo(Customer.NamedChanged.class));
+ }
+
+ @Test
+ public void withDefaultEvent() {
+
+ class Customer {
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ addGetterFacet(facetedMethod);
+ addSetterFacet(facetedMethod);
+ addClearFacet(facetedMethod);
+
+ // expect
+ allowingLoadSpecificationRequestsFor(cls, propertyMethod.getReturnType());
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processModify(processMethodContext);
+
+ // then
+ final Facet domainEventFacet = facetedMethod.getFacet(PropertyDomainEventFacet.class);
+ Assert.assertNotNull(domainEventFacet);
+ Assert.assertTrue(domainEventFacet instanceof PropertyDomainEventFacetDefault);
+ PropertyDomainEventFacetDefault domainEventFacetImpl = (PropertyDomainEventFacetDefault) domainEventFacet;
+ assertThat(domainEventFacetImpl.value(), classEqualTo(PropertyDomainEvent.Default.class));
+
+ // then
+ final Facet setterFacet = facetedMethod.getFacet(PropertySetterFacet.class);
+ Assert.assertNotNull(setterFacet);
+ Assert.assertTrue(setterFacet instanceof PropertySetterFacetForDomainEventFromDefault);
+ PropertySetterFacetForDomainEventFromDefault setterFacetImpl = (PropertySetterFacetForDomainEventFromDefault) setterFacet;
+ assertThat(setterFacetImpl.value(), classEqualTo(PropertyDomainEvent.Default.class));
+
+ // then
+ final Facet clearFacet = facetedMethod.getFacet(PropertyClearFacet.class);
+ Assert.assertNotNull(clearFacet);
+ Assert.assertTrue(clearFacet instanceof PropertyClearFacetForDomainEventFromDefault);
+ PropertyClearFacetForDomainEventFromDefault clearFacetImpl = (PropertyClearFacetForDomainEventFromDefault) clearFacet;
+ assertThat(clearFacetImpl.value(), classEqualTo(PropertyDomainEvent.Default.class));
+ }
+ }
+
+ public static class Hidden extends PropertyAnnotationFacetFactoryTest {
+
+ @Test
+ public void withAnnotation() {
+
+ class Customer {
+ @Property(hidden = Where.REFERENCES_PARENT)
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processHidden(processMethodContext);
+
+ // then
+ final HiddenFacet hiddenFacet = facetedMethod.getFacet(HiddenFacet.class);
+ Assert.assertNotNull(hiddenFacet);
+ Assert.assertTrue(hiddenFacet instanceof HiddenFacetForPropertyAnnotation);
+ HiddenFacetForPropertyAnnotation hiddenFacetImpl = (HiddenFacetForPropertyAnnotation) hiddenFacet;
+ assertThat(hiddenFacetImpl.where(), is(Where.REFERENCES_PARENT));
+ assertThat(hiddenFacetImpl.when(), is(When.ALWAYS));
+
+ final Facet hiddenFacetForProp = facetedMethod.getFacet(HiddenFacetForPropertyAnnotation.class);
+ Assert.assertNotNull(hiddenFacetForProp);
+ Assert.assertTrue(hiddenFacet == hiddenFacetForProp);
+ }
+
+ }
+
+ public static class Editing extends PropertyAnnotationFacetFactoryTest {
+
+ @Test
+ public void withAnnotation() {
+
+ class Customer {
+ @Property(
+ editing = org.apache.isis.applib.annotation.Editing.DISABLED,
+ editingDisabledReason = "you cannot edit the name property"
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processEditing(processMethodContext);
+
+ // then
+ final DisabledFacet disabledFacet = facetedMethod.getFacet(DisabledFacet.class);
+ Assert.assertNotNull(disabledFacet);
+ Assert.assertTrue(disabledFacet instanceof DisabledFacetForPropertyAnnotation);
+ DisabledFacetForPropertyAnnotation disabledFacetImpl = (DisabledFacetForPropertyAnnotation) disabledFacet;
+ assertThat(disabledFacet.where(), is(Where.EVERYWHERE));
+ assertThat(disabledFacet.when(), is(When.ALWAYS));
+ assertThat(disabledFacetImpl.getReason(), is("you cannot edit the name property"));
+ }
+ }
+
+ public static class MaxLength extends PropertyAnnotationFacetFactoryTest {
+
+ @Test
+ public void withAnnotation() {
+
+ class Customer {
+ @Property(
+ maxLength = 30
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processMaxLength(processMethodContext);
+
+ // then
+ final MaxLengthFacet maxLengthFacet = facetedMethod.getFacet(MaxLengthFacet.class);
+ Assert.assertNotNull(maxLengthFacet);
+ Assert.assertTrue(maxLengthFacet instanceof MaxLengthFacetForPropertyAnnotation);
+ assertThat(maxLengthFacet.value(), is(30));
+ }
+ }
+
+ public static class MustSatisfy extends PropertyAnnotationFacetFactoryTest {
+
+ public static class NotTooHot implements Specification {
+ @Override
+ public String satisfies(final Object obj) {
+ return null;
+ }
+ }
+
+ public static class NotTooCold implements Specification {
+ @Override
+ public String satisfies(final Object obj) {
+ return null;
+ }
+ }
+
+
+ @Test
+ public void withAnnotation() {
+
+ class Customer {
+ @Property(
+ mustSatisfy = {NotTooHot.class, NotTooCold.class}
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processMustSatisfy(processMethodContext);
+
+ // then
+ final MustSatisfySpecificationFacet mustSatisfySpecificationFacet = facetedMethod.getFacet(MustSatisfySpecificationFacet.class);
+ Assert.assertNotNull(mustSatisfySpecificationFacet);
+ Assert.assertTrue(mustSatisfySpecificationFacet instanceof MustSatisfySpecificationFacetForPropertyAnnotation);
+ MustSatisfySpecificationFacetForPropertyAnnotation mustSatisfySpecificationFacetImpl = (MustSatisfySpecificationFacetForPropertyAnnotation) mustSatisfySpecificationFacet;
+ List<Specification> specifications = mustSatisfySpecificationFacetImpl.getSpecifications();
+ assertThat(specifications.size(), is(2));
+
+ assertTrue(specifications.get(0) instanceof NotTooHot);
+ assertTrue(specifications.get(1) instanceof NotTooCold);
+ }
+
+ }
+
+ public static class NotPersisted extends PropertyAnnotationFacetFactoryTest {
+
+ @Test
+ public void withAnnotation() {
+
+ class Customer {
+ @Property(
+ notPersisted = true
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processNotPersisted(processMethodContext);
+
+ // then
+ final NotPersistedFacet notPersistedFacet = facetedMethod.getFacet(NotPersistedFacet.class);
+ Assert.assertNotNull(notPersistedFacet);
+ Assert.assertTrue(notPersistedFacet instanceof NotPersistedFacetForPropertyAnnotation);
+ }
+
+ }
+
+ public static class Mandatory extends PropertyAnnotationFacetFactoryTest {
+
+ @Test
+ public void whenOptionalityIsTrue() {
+
+ class Customer {
+ @Property(
+ optional = Optionality.TRUE
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processOptional(processMethodContext);
+
+ // then
+ final MandatoryFacet mandatoryFacet = facetedMethod.getFacet(MandatoryFacet.class);
+ Assert.assertNotNull(mandatoryFacet);
+ Assert.assertTrue(mandatoryFacet instanceof MandatoryFacetForPropertyAnnotation.Optional);
+ }
+
+ @Test
+ public void whenOptionalityIsFalse() {
+
+ class Customer {
+ @Property(
+ optional = Optionality.FALSE
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processOptional(processMethodContext);
+
+ // then
+ final MandatoryFacet mandatoryFacet = facetedMethod.getFacet(MandatoryFacet.class);
+ Assert.assertNotNull(mandatoryFacet);
+ Assert.assertTrue(mandatoryFacet instanceof MandatoryFacetForPropertyAnnotation.Required);
+ }
+
+ @Test
+ public void whenOptionalityIsDefault() {
+
+ class Customer {
+ @Property(
+ optional = Optionality.DEFAULT
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processOptional(processMethodContext);
+
+ // then
+ final MandatoryFacet mandatoryFacet = facetedMethod.getFacet(MandatoryFacet.class);
+ Assert.assertNull(mandatoryFacet);
+ }
+
+ @Test
+ public void whenNone() {
+
+ class Customer {
+ @Property(
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processOptional(processMethodContext);
+
+ // then
+ final MandatoryFacet mandatoryFacet = facetedMethod.getFacet(MandatoryFacet.class);
+ Assert.assertNull(mandatoryFacet);
+ }
+
+ }
+ public static class RegEx extends PropertyAnnotationFacetFactoryTest {
+
+ @Test
+ public void whenHasAnnotation() {
+
+ class Customer {
+ @Property(
+ regexPattern = "[123].*",
+ regexPatternFlags = Pattern.CASE_INSENSITIVE | Pattern.MULTILINE
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processRegEx(processMethodContext);
+
+ // then
+ final RegExFacet regExFacet = facetedMethod.getFacet(RegExFacet.class);
+ Assert.assertNotNull(regExFacet);
+ Assert.assertTrue(regExFacet instanceof RegExFacetForPropertyAnnotation);
+ assertThat(regExFacet.caseSensitive(), is(true));
+ assertThat(regExFacet.validation(), is("[123].*"));
+ }
+
+ @Test
+ public void whenNone() {
+
+ class Customer {
+ @Property(
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processRegEx(processMethodContext);
+
+ // then
+ final RegExFacet regExFacet = facetedMethod.getFacet(RegExFacet.class);
+ Assert.assertNull(regExFacet);
+ }
+
+ @Test
+ public void whenEmptyString() {
+
+ class Customer {
+ @Property(
+ regexPattern = ""
+ )
+ public String getName() {
+ return null;
+ }
+ public void setName(final String name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processRegEx(processMethodContext);
+
+ // then
+ final RegExFacet regExFacet = facetedMethod.getFacet(RegExFacet.class);
+ Assert.assertNull(regExFacet);
+ }
+
+ @Test
+ public void whenNotAnnotatedOnStringProperty() {
+
+ class Customer {
+ @Property(
+ regexPattern = "[abc].*"
+ )
+ public int getName() {
+ return 0;
+ }
+ public void setName(final int name) {
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ propertyMethod = findMethod(Customer.class, "getName");
+
+ // when
+ final FacetFactory.ProcessMethodContext processMethodContext = new FacetFactory.ProcessMethodContext(cls, null, null, propertyMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processRegEx(processMethodContext);
+
+ // then
+ final RegExFacet regExFacet = facetedMethod.getFacet(RegExFacet.class);
+ Assert.assertNull(regExFacet);
+ }
+
+ }
+
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/test/java/org/apache/isis/core/metamodel/specloader/specimpl/ObjectAssociationAbstractTest_alwaysHidden.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/specloader/specimpl/ObjectAssociationAbstractTest_alwaysHidden.java b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/specloader/specimpl/ObjectAssociationAbstractTest_alwaysHidden.java
index 9c62e3e..0e96045 100644
--- a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/specloader/specimpl/ObjectAssociationAbstractTest_alwaysHidden.java
+++ b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/specloader/specimpl/ObjectAssociationAbstractTest_alwaysHidden.java
@@ -19,7 +19,6 @@
package org.apache.isis.core.metamodel.specloader.specimpl;
-import org.jmock.Expectations;
import org.jmock.auto.Mock;
import org.junit.Before;
import org.junit.Rule;
@@ -31,9 +30,11 @@ import org.apache.isis.core.metamodel.adapter.ObjectAdapter;
import org.apache.isis.core.metamodel.consent.InteractionInvocationMethod;
import org.apache.isis.core.metamodel.deployment.DeploymentCategory;
import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facetapi.FacetUtil;
import org.apache.isis.core.metamodel.facetapi.FeatureType;
import org.apache.isis.core.metamodel.facets.FacetedMethod;
import org.apache.isis.core.metamodel.facets.all.hide.HiddenFacet;
+import org.apache.isis.core.metamodel.facets.members.hidden.HiddenFacetAbstract;
import org.apache.isis.core.metamodel.interactions.UsabilityContext;
import org.apache.isis.core.metamodel.interactions.VisibilityContext;
import org.apache.isis.core.metamodel.spec.Instance;
@@ -54,16 +55,11 @@ public class ObjectAssociationAbstractTest_alwaysHidden {
private FacetedMethod facetedMethod;
@Mock
- private ObjectSpecification objectSpecification;
-
- @Mock
- private HiddenFacet facet;
+ private ObjectSpecification mockObjectSpecification;
public static class Customer {
- private String firstName;
-
public String getFirstName() {
- return firstName;
+ return null;
}
}
@@ -71,7 +67,9 @@ public class ObjectAssociationAbstractTest_alwaysHidden {
public void setup() {
facetedMethod = FacetedMethod.createForProperty(Customer.class, "firstName");
- objectAssociation = new ObjectAssociationAbstract(facetedMethod, FeatureType.PROPERTY, objectSpecification, new ObjectMemberContext(DeploymentCategory.PRODUCTION, null, null, null, null, null)) {
+ objectAssociation = new ObjectAssociationAbstract(
+ facetedMethod, FeatureType.PROPERTY, mockObjectSpecification,
+ new ObjectMemberContext(DeploymentCategory.PRODUCTION, null, null, null, null, null)) {
@Override
public ObjectAdapter get(final ObjectAdapter fromObject) {
@@ -98,12 +96,12 @@ public class ObjectAssociationAbstractTest_alwaysHidden {
}
@Override
- public UsabilityContext<?> createUsableInteractionContext(final AuthenticationSession session, final InteractionInvocationMethod invocationMethod, final ObjectAdapter target, Where where) {
+ public UsabilityContext<?> createUsableInteractionContext(final AuthenticationSession session, final InteractionInvocationMethod invocationMethod, final ObjectAdapter target, final Where where) {
return null;
}
@Override
- public VisibilityContext<?> createVisibleInteractionContext(final AuthenticationSession session, final InteractionInvocationMethod invocationMethod, final ObjectAdapter targetObjectAdapter, Where where) {
+ public VisibilityContext<?> createVisibleInteractionContext(final AuthenticationSession session, final InteractionInvocationMethod invocationMethod, final ObjectAdapter targetObjectAdapter, final Where where) {
return null;
}
@@ -136,66 +134,80 @@ public class ObjectAssociationAbstractTest_alwaysHidden {
return 0;
}
};
-
- context.checking(new Expectations() {
- {
- allowing(facet).facetType();
- will(returnValue(HiddenFacet.class));
- }
- });
-
}
@Test
- public void alwaysHidden_forHiddenAlwaysEverywhere() throws Exception {
- context.checking(new Expectations() {
- {
- allowing(facet).isNoop();
- will(returnValue(false));
- allowing(facet).when();
- will(returnValue(When.ALWAYS));
- allowing(facet).where();
- will(returnValue(Where.ANYWHERE));
- allowing(facet).where();
- will(returnValue(Where.OBJECT_FORMS));
- }
- });
- facetedMethod.addFacet(facet);
- assertTrue(objectAssociation.isAlwaysHidden());
+ public void whenNone() throws Exception {
+
+ // given (none)
+
+ // when, then
+ assertFalse(objectAssociation.isAlwaysHidden());
}
+ @Test
+ public void whenNoop() throws Exception {
+
+ // given
+ addHiddenFacet(When.ALWAYS, Where.EVERYWHERE, facetedMethod, true);
+
+ // when, then
+ assertFalse(objectAssociation.isAlwaysHidden());
+ }
@Test
- public void alwaysHidden_forHiddenAlwaysObjectForm() throws Exception {
- context.checking(new Expectations() {
- {
- allowing(facet).isNoop();
- will(returnValue(false));
- allowing(facet).when();
- will(returnValue(When.ALWAYS));
- allowing(facet).where();
- will(returnValue(Where.OBJECT_FORMS));
- }
- });
- facetedMethod.addFacet(facet);
+ public void whenNotAlwaysEverywhere() throws Exception {
+
+ // given
+ addHiddenFacet(When.ONCE_PERSISTED, Where.EVERYWHERE, facetedMethod, false);
+
+ // when, then
assertFalse(objectAssociation.isAlwaysHidden());
}
-
+
@Test
- public void alwaysHidden_forHiddenOncePersistedAnywhere() throws Exception {
- context.checking(new Expectations() {
- {
- allowing(facet).isNoop();
- will(returnValue(false));
- allowing(facet).when();
- will(returnValue(When.ONCE_PERSISTED));
- allowing(facet).where();
- will(returnValue(Where.ANYWHERE));
- }
- });
- facetedMethod.addFacet(facet);
+ public void whenAlwaysNotEverywhere() throws Exception {
+
+ // given
+ addHiddenFacet(When.ALWAYS, Where.OBJECT_FORMS, facetedMethod, false);
+
+ // when, then
assertFalse(objectAssociation.isAlwaysHidden());
}
+ @Test
+ public void whenAlwaysEverywhere() throws Exception {
+
+ // given
+ addHiddenFacet(When.ALWAYS, Where.EVERYWHERE, facetedMethod, false);
+
+ // when, then
+ assertTrue(objectAssociation.isAlwaysHidden());
+ }
+
+ @Test
+ public void whenAlwaysAnywhere() throws Exception {
+
+ // given
+ addHiddenFacet(When.ALWAYS, Where.ANYWHERE, facetedMethod, false);
+
+ // when, then
+ assertTrue(objectAssociation.isAlwaysHidden());
+ }
+
+ private static void addHiddenFacet(final When when, final Where where, final FacetedMethod holder, final boolean noop) {
+ HiddenFacet facet = new HiddenFacetAbstract(HiddenFacet.class, when, where, holder) {
+ @Override
+ protected String hiddenReason(final ObjectAdapter target, final Where whereContext) {
+ return null;
+ }
+
+ @Override
+ public boolean isNoop() {
+ return noop;
+ }
+ };
+ FacetUtil.addFacet(facet);
+ }
}
[2/2] isis git commit: ISIS-970: unit testing @Property annotation
Posted by da...@apache.org.
ISIS-970: unit testing @Property annotation
Project: http://git-wip-us.apache.org/repos/asf/isis/repo
Commit: http://git-wip-us.apache.org/repos/asf/isis/commit/c459aa5e
Tree: http://git-wip-us.apache.org/repos/asf/isis/tree/c459aa5e
Diff: http://git-wip-us.apache.org/repos/asf/isis/diff/c459aa5e
Branch: refs/heads/ISIS-970
Commit: c459aa5e8c39da6dfe5098350f03cae3409a9716
Parents: 97c1e3d
Author: Dan Haywood <da...@haywood-associates.co.uk>
Authored: Thu Jan 22 15:16:42 2015 +0000
Committer: Dan Haywood <da...@haywood-associates.co.uk>
Committed: Thu Jan 22 15:16:42 2015 +0000
----------------------------------------------------------------------
.../action/ActionAnnotationFacetFactory.java | 4 +-
.../ActionDomainEventFacetAbstract.java | 10 +-
.../ActionDomainEventFacetDefault.java | 1 +
...onInvocationFacetForDomainEventAbstract.java | 7 +
.../PropertyAnnotationFacetFactory.java | 19 +-
...ntFacetForPropertyInteractionAnnotation.java | 4 +
...SpecificationFacetForPropertyAnnotation.java | 2 +
.../regex/RegExFacetForPropertyAnnotation.java | 6 +-
.../MustSatisfySpecificationFacetAbstract.java | 8 +-
.../ActionAnnotationFacetFactoryTest.java | 198 ++++-
...ectionAnnotationFacetFactoryTest_typeOf.java | 258 +++++++
.../TypeOfAnnotationFacetFactoryTest.java | 297 --------
.../PropertyAnnotationFacetFactoryTest.java | 759 +++++++++++++++++++
...ectAssociationAbstractTest_alwaysHidden.java | 130 ++--
14 files changed, 1325 insertions(+), 378 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactory.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactory.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactory.java
index 4cd5439..eecdc03 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactory.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactory.java
@@ -106,7 +106,7 @@ public class ActionAnnotationFacetFactory extends FacetFactoryAbstract implement
processHidden(processMethodContext);
processRestrictTo(processMethodContext);
processSemantics(processMethodContext);
- processInvokeOn(processMethodContext);
+ processBulk(processMethodContext);
// must come after processing semantics
processCommand(processMethodContext);
@@ -252,7 +252,7 @@ public class ActionAnnotationFacetFactory extends FacetFactoryAbstract implement
FacetUtil.addFacet(facet);
}
- void processInvokeOn(final ProcessMethodContext processMethodContext) {
+ void processBulk(final ProcessMethodContext processMethodContext) {
final Method method = processMethodContext.getMethod();
final Action action = Annotations.getAnnotation(method, Action.class);
final FacetHolder holder = processMethodContext.getFacetHolder();
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetAbstract.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetAbstract.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetAbstract.java
index 46ea774..7d5a915 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetAbstract.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetAbstract.java
@@ -125,8 +125,16 @@ public abstract class ActionDomainEventFacetAbstract
return null;
}
- private Class<?> eventType() {
+ protected Class eventType() {
return value();
}
+ /**
+ * For testing only.
+ */
+ public Class<? extends ActionDomainEvent<?>> getEventType() {
+ //noinspection unchecked
+ return eventType();
+ }
+
}
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetDefault.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetDefault.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetDefault.java
index f92ce63..f36ad6e 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetDefault.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionDomainEventFacetDefault.java
@@ -32,4 +32,5 @@ public class ActionDomainEventFacetDefault extends ActionDomainEventFacetAbstrac
super(eventType, holder, servicesInjector, specificationLoader);
}
+
}
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionInvocationFacetForDomainEventAbstract.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionInvocationFacetForDomainEventAbstract.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionInvocationFacetForDomainEventAbstract.java
index 89abf44..ec534c8 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionInvocationFacetForDomainEventAbstract.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/actions/action/invocation/ActionInvocationFacetForDomainEventAbstract.java
@@ -220,6 +220,13 @@ public abstract class ActionInvocationFacetForDomainEventAbstract
return event;
}
+ /**
+ * For testing only.
+ */
+ public Class<? extends ActionDomainEvent<?>> getEventType() {
+ return eventType;
+ }
+
protected InvocationResult internalInvoke(
final Command command,
final ObjectAction owningAction,
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactory.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactory.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactory.java
index d480257..e097db0 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactory.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/PropertyAnnotationFacetFactory.java
@@ -23,6 +23,7 @@ import java.lang.reflect.Method;
import org.apache.isis.applib.annotation.PostsPropertyChangedEvent;
import org.apache.isis.applib.annotation.Property;
import org.apache.isis.applib.annotation.PropertyInteraction;
+import org.apache.isis.applib.services.eventbus.PropertyChangedEvent;
import org.apache.isis.applib.services.eventbus.PropertyDomainEvent;
import org.apache.isis.core.metamodel.facetapi.Facet;
import org.apache.isis.core.metamodel.facetapi.FacetHolder;
@@ -91,7 +92,7 @@ public class PropertyAnnotationFacetFactory extends FacetFactoryAbstract impleme
void processModify(final ProcessMethodContext processMethodContext) {
final Method method = processMethodContext.getMethod();
- FacetedMethod holder = processMethodContext.getFacetHolder();
+ final FacetedMethod holder = processMethodContext.getFacetHolder();
final PropertyOrCollectionAccessorFacet getterFacet = holder.getFacet(PropertyOrCollectionAccessorFacet.class);
if(getterFacet == null) {
@@ -101,6 +102,7 @@ public class PropertyAnnotationFacetFactory extends FacetFactoryAbstract impleme
//
// Set up PropertyDomainEventFacet, which will act as the hiding/disabling/validating advisor
//
+ final PostsPropertyChangedEvent postsPropertyChangedEvent = Annotations.getAnnotation(method, PostsPropertyChangedEvent.class);
final Property property = Annotations.getAnnotation(method, Property.class);
final PropertyInteraction propertyInteraction = Annotations.getAnnotation(method, PropertyInteraction.class);
final Class<? extends PropertyDomainEvent<?, ?>> propertyDomainEventType;
@@ -120,7 +122,7 @@ public class PropertyAnnotationFacetFactory extends FacetFactoryAbstract impleme
propertyDomainEventType, getterFacet, servicesInjector, getSpecificationLoader(), holder);
} else
- // else use default event type
+ // else use default event type (also for @PostsPropertyChangedEvent)
{
propertyDomainEventType = PropertyDomainEvent.Default.class;
propertyDomainEventFacet = new PropertyDomainEventFacetDefault(
@@ -134,17 +136,15 @@ public class PropertyAnnotationFacetFactory extends FacetFactoryAbstract impleme
// emit the appropriate domain event and then delegate onto the underlying
//
-
- final PostsPropertyChangedEvent postsPropertyChangedEvent = Annotations.getAnnotation(method, PostsPropertyChangedEvent.class);
-
final PropertySetterFacet setterFacet = holder.getFacet(PropertySetterFacet.class);
if(setterFacet != null) {
// the current setter facet will end up as the underlying facet
final PropertySetterFacetForDomainEventAbstract replacementFacet;
// deprecated
if(postsPropertyChangedEvent != null) {
+ final Class<? extends PropertyChangedEvent<?, ?>> propertySetEventType = postsPropertyChangedEvent.value();
replacementFacet = new PropertySetterFacetForPostsPropertyChangedEventAnnotation(
- postsPropertyChangedEvent.value(), getterFacet, setterFacet, propertyDomainEventFacet, holder, servicesInjector);
+ propertySetEventType, getterFacet, setterFacet, propertyDomainEventFacet, holder, servicesInjector);
} else
// deprecated (but more recently)
if(propertyInteraction != null) {
@@ -159,7 +159,7 @@ public class PropertyAnnotationFacetFactory extends FacetFactoryAbstract impleme
// default
{
replacementFacet = new PropertySetterFacetForDomainEventFromDefault(
- PropertyDomainEvent.Default.class, getterFacet, setterFacet, propertyDomainEventFacet, holder, servicesInjector);
+ propertyDomainEventType, getterFacet, setterFacet, propertyDomainEventFacet, holder, servicesInjector);
}
FacetUtil.addFacet(replacementFacet);
}
@@ -171,8 +171,9 @@ public class PropertyAnnotationFacetFactory extends FacetFactoryAbstract impleme
// deprecated
if(postsPropertyChangedEvent != null) {
+ final Class<? extends PropertyChangedEvent<?, ?>> propertyClearEventType = postsPropertyChangedEvent.value();
replacementFacet = new PropertyClearFacetForPostsPropertyChangedEventAnnotation(
- postsPropertyChangedEvent.value(), getterFacet, clearFacet, propertyDomainEventFacet, holder, servicesInjector);
+ propertyClearEventType, getterFacet, clearFacet, propertyDomainEventFacet, holder, servicesInjector);
} else
// deprecated (but more recently)
if(propertyInteraction != null) {
@@ -186,7 +187,7 @@ public class PropertyAnnotationFacetFactory extends FacetFactoryAbstract impleme
} else
{
replacementFacet = new PropertyClearFacetForDomainEventFromDefault(
- PropertyDomainEvent.Default.class, getterFacet, clearFacet, propertyDomainEventFacet, holder, servicesInjector);
+ propertyDomainEventType, getterFacet, clearFacet, propertyDomainEventFacet, holder, servicesInjector);
}
FacetUtil.addFacet(replacementFacet);
}
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/modify/PropertyDomainEventFacetForPropertyInteractionAnnotation.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/modify/PropertyDomainEventFacetForPropertyInteractionAnnotation.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/modify/PropertyDomainEventFacetForPropertyInteractionAnnotation.java
index 9d6ec19..c0cbbb2 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/modify/PropertyDomainEventFacetForPropertyInteractionAnnotation.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/modify/PropertyDomainEventFacetForPropertyInteractionAnnotation.java
@@ -25,6 +25,10 @@ import org.apache.isis.core.metamodel.facets.propcoll.accessor.PropertyOrCollect
import org.apache.isis.core.metamodel.runtimecontext.ServicesInjector;
import org.apache.isis.core.metamodel.spec.SpecificationLoader;
+/**
+ * @deprecated
+ */
+@Deprecated
public class PropertyDomainEventFacetForPropertyInteractionAnnotation extends PropertyDomainEventFacetAbstract {
public PropertyDomainEventFacetForPropertyInteractionAnnotation(
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/mustsatisfy/MustSatisfySpecificationFacetForPropertyAnnotation.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/mustsatisfy/MustSatisfySpecificationFacetForPropertyAnnotation.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/mustsatisfy/MustSatisfySpecificationFacetForPropertyAnnotation.java
index db5f5eb..f2939d0 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/mustsatisfy/MustSatisfySpecificationFacetForPropertyAnnotation.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/mustsatisfy/MustSatisfySpecificationFacetForPropertyAnnotation.java
@@ -53,4 +53,6 @@ public class MustSatisfySpecificationFacetForPropertyAnnotation extends MustSati
super(specifications, holder);
}
+
+
}
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/regex/RegExFacetForPropertyAnnotation.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/regex/RegExFacetForPropertyAnnotation.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/regex/RegExFacetForPropertyAnnotation.java
index 96c445d..047ed76 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/regex/RegExFacetForPropertyAnnotation.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/properties/property/regex/RegExFacetForPropertyAnnotation.java
@@ -20,6 +20,7 @@
package org.apache.isis.core.metamodel.facets.properties.property.regex;
import java.util.regex.Pattern;
+import com.google.common.base.Strings;
import org.apache.isis.applib.annotation.Property;
import org.apache.isis.core.metamodel.facetapi.FacetHolder;
import org.apache.isis.core.metamodel.facets.object.regex.RegExFacet;
@@ -38,13 +39,16 @@ public class RegExFacetForPropertyAnnotation extends RegExFacetAbstract {
}
final String pattern = property.regexPattern();
+ if(Strings.isNullOrEmpty(pattern)) {
+ return null;
+ }
final int patternFlags = property.regexPatternFlags();
return new RegExFacetForPropertyAnnotation(pattern, patternFlags, holder);
}
private RegExFacetForPropertyAnnotation(final String pattern, final int patternFlags, final FacetHolder holder) {
- super(pattern, "", false, holder);
+ super(pattern, "", (patternFlags & Pattern.CASE_INSENSITIVE) == Pattern.CASE_INSENSITIVE, holder);
this.pattern = Pattern.compile(pattern, patternFlags);
}
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/propparam/mustsatisfyspec/MustSatisfySpecificationFacetAbstract.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/propparam/mustsatisfyspec/MustSatisfySpecificationFacetAbstract.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/propparam/mustsatisfyspec/MustSatisfySpecificationFacetAbstract.java
index 6db0d96..f80303c 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/propparam/mustsatisfyspec/MustSatisfySpecificationFacetAbstract.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/facets/propparam/mustsatisfyspec/MustSatisfySpecificationFacetAbstract.java
@@ -38,6 +38,13 @@ public abstract class MustSatisfySpecificationFacetAbstract extends FacetAbstrac
private final List<Specification> specifications;
+ /**
+ * For testing.
+ */
+ public List<Specification> getSpecifications() {
+ return specifications;
+ }
+
public MustSatisfySpecificationFacetAbstract(final List<Specification> specifications, final FacetHolder holder) {
super(type(), holder, Derivation.NOT_DERIVED);
this.specifications = specifications;
@@ -77,5 +84,4 @@ public abstract class MustSatisfySpecificationFacetAbstract extends FacetAbstrac
}
}
-
}
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactoryTest.java b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactoryTest.java
index 499e9f2..e495647 100644
--- a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactoryTest.java
+++ b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/actions/action/ActionAnnotationFacetFactoryTest.java
@@ -20,6 +20,7 @@
package org.apache.isis.core.metamodel.facets.actions.action;
import java.lang.reflect.Method;
+import java.util.Collection;
import java.util.List;
import java.util.UUID;
import org.jmock.Expectations;
@@ -52,6 +53,9 @@ import org.apache.isis.applib.services.publish.EventPayload;
import org.apache.isis.core.metamodel.facetapi.Facet;
import org.apache.isis.core.metamodel.facets.AbstractFacetFactoryJUnit4TestCase;
import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacet;
+import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacetInferredFromArray;
+import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacetInferredFromGenerics;
import org.apache.isis.core.metamodel.facets.actions.action.command.CommandFacetForActionAnnotation;
import org.apache.isis.core.metamodel.facets.actions.action.command.CommandFacetForActionAnnotationAsConfigured;
import org.apache.isis.core.metamodel.facets.actions.action.command.CommandFacetForCommandAnnotation;
@@ -69,6 +73,8 @@ import org.apache.isis.core.metamodel.facets.actions.action.invocation.ActionInv
import org.apache.isis.core.metamodel.facets.actions.action.publishing.PublishedActionFacetForActionAnnotation;
import org.apache.isis.core.metamodel.facets.actions.action.publishing.PublishedActionFacetForPublishedActionAnnotation;
import org.apache.isis.core.metamodel.facets.actions.action.publishing.PublishedActionFacetFromConfiguration;
+import org.apache.isis.core.metamodel.facets.actions.action.typeof.TypeOfFacetForActionAnnotation;
+import org.apache.isis.core.metamodel.facets.actions.action.typeof.TypeOfFacetOnActionForTypeOfAnnotation;
import org.apache.isis.core.metamodel.facets.actions.bulk.BulkFacet;
import org.apache.isis.core.metamodel.facets.actions.command.CommandFacet;
import org.apache.isis.core.metamodel.facets.actions.prototype.PrototypeFacet;
@@ -79,6 +85,7 @@ import org.apache.isis.core.metamodel.facets.actions.semantics.ActionSemanticsFa
import org.apache.isis.core.metamodel.facets.all.hide.HiddenFacet;
import org.apache.isis.core.metamodel.spec.ObjectSpecification;
+import static org.apache.isis.core.commons.matchers.IsisMatchers.classEqualTo;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
@@ -97,9 +104,9 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
@Mock
ObjectSpecification mockReturnTypeSpec;
- void expectRemoveMethod(final Method actionMethod1) {
+ void expectRemoveMethod(final Method actionMethod) {
context.checking(new Expectations() {{
- oneOf(mockMethodRemover).removeMethod(actionMethod1);
+ oneOf(mockMethodRemover).removeMethod(actionMethod);
}});
}
@@ -179,11 +186,15 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
// then
final Facet domainEventFacet = facetedMethod.getFacet(ActionDomainEventFacet.class);
Assert.assertNotNull(domainEventFacet);
- Assert.assertTrue(domainEventFacet instanceof ActionDomainEventFacetDefault); // this is discarded at runtime, see ActionInvocationFacetForPostsActionInvokedEventAnnotation#verify(...)
+ Assert.assertTrue(domainEventFacet instanceof ActionDomainEventFacetDefault);
+ final ActionDomainEventFacetDefault domainEventFacetImpl = (ActionDomainEventFacetDefault) domainEventFacet;
+ assertThat(domainEventFacetImpl.getEventType(), classEqualTo(ActionDomainEvent.Default.class)); // this is discarded at runtime, see ActionInvocationFacetForPostsActionInvokedEventAnnotation#verify(...)
final Facet invocationFacet = facetedMethod.getFacet(ActionInvocationFacet.class);
Assert.assertNotNull(invocationFacet);
Assert.assertTrue(invocationFacet instanceof ActionInvocationFacetForPostsActionInvokedEventAnnotation);
+ final ActionInvocationFacetForPostsActionInvokedEventAnnotation invocationFacetImpl = (ActionInvocationFacetForPostsActionInvokedEventAnnotation) invocationFacet;
+ assertThat(invocationFacetImpl.getEventType(), classEqualTo(Customer.SomeActionInvoked.class));
}
@Test
@@ -218,10 +229,14 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
final Facet domainEventFacet = facetedMethod.getFacet(ActionDomainEventFacet.class);
Assert.assertNotNull(domainEventFacet);
Assert.assertTrue(domainEventFacet instanceof ActionDomainEventFacetForActionInteractionAnnotation);
+ final ActionDomainEventFacetForActionInteractionAnnotation domainEventFacetImpl = (ActionDomainEventFacetForActionInteractionAnnotation) domainEventFacet;
+ assertThat(domainEventFacetImpl.getEventType(), classEqualTo(Customer.SomeActionInvoked.class));
final Facet invocationFacet = facetedMethod.getFacet(ActionInvocationFacet.class);
Assert.assertNotNull(invocationFacet);
Assert.assertTrue(invocationFacet instanceof ActionInvocationFacetForDomainEventFromActionInteractionAnnotation);
+ final ActionInvocationFacetForDomainEventFromActionInteractionAnnotation invocationFacetImpl = (ActionInvocationFacetForDomainEventFromActionInteractionAnnotation) invocationFacet;
+ assertThat(invocationFacetImpl.getEventType(), classEqualTo(Customer.SomeActionInvoked.class));
}
@Test
@@ -256,10 +271,14 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
final Facet domainEventFacet = facetedMethod.getFacet(ActionDomainEventFacet.class);
Assert.assertNotNull(domainEventFacet);
Assert.assertTrue(domainEventFacet instanceof ActionDomainEventFacetForActionAnnotation);
+ final ActionDomainEventFacetForActionAnnotation domainEventFacetImpl = (ActionDomainEventFacetForActionAnnotation) domainEventFacet;
+ assertThat(domainEventFacetImpl.getEventType(), classEqualTo(Customer.SomeActionInvoked.class));
final Facet invocationFacet = facetedMethod.getFacet(ActionInvocationFacet.class);
Assert.assertNotNull(invocationFacet);
Assert.assertTrue(invocationFacet instanceof ActionInvocationFacetForDomainEventFromActionAnnotation);
+ final ActionInvocationFacetForDomainEventFromActionAnnotation invocationFacetImpl = (ActionInvocationFacetForDomainEventFromActionAnnotation) invocationFacet;
+ assertThat(invocationFacetImpl.getEventType(), classEqualTo(Customer.SomeActionInvoked.class));
}
@Test
@@ -286,10 +305,14 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
final Facet domainEventFacet = facetedMethod.getFacet(ActionDomainEventFacet.class);
Assert.assertNotNull(domainEventFacet);
Assert.assertTrue(domainEventFacet instanceof ActionDomainEventFacetDefault);
+ final ActionDomainEventFacetDefault domainEventFacetImpl = (ActionDomainEventFacetDefault) domainEventFacet;
+ assertThat(domainEventFacetImpl.getEventType(), classEqualTo(ActionDomainEvent.Default.class));
final Facet invocationFacet = facetedMethod.getFacet(ActionInvocationFacet.class);
Assert.assertNotNull(invocationFacet);
Assert.assertTrue(invocationFacet instanceof ActionInvocationFacetForDomainEventFromDefault);
+ final ActionInvocationFacetForDomainEventFromDefault invocationFacetImpl = (ActionInvocationFacetForDomainEventFromDefault) invocationFacet;
+ assertThat(invocationFacetImpl.getEventType(), classEqualTo(ActionDomainEvent.Default.class));
}
}
@@ -625,7 +648,7 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
// when
final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
- facetFactory.processInvokeOn(processMethodContext);
+ facetFactory.processBulk(processMethodContext);
// then
final BulkFacet facet = facetedMethod.getFacet(BulkFacet.class);
@@ -649,7 +672,7 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
// when
final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
- facetFactory.processInvokeOn(processMethodContext);
+ facetFactory.processBulk(processMethodContext);
// then
final BulkFacet facet = facetedMethod.getFacet(BulkFacet.class);
@@ -672,7 +695,7 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
// when
final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
- facetFactory.processInvokeOn(processMethodContext);
+ facetFactory.processBulk(processMethodContext);
// then
final BulkFacet facet = facetedMethod.getFacet(BulkFacet.class);
@@ -695,7 +718,7 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
// when
final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
- facetFactory.processInvokeOn(processMethodContext);
+ facetFactory.processBulk(processMethodContext);
// then
final BulkFacet facet = facetedMethod.getFacet(BulkFacet.class);
@@ -719,7 +742,7 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
// when
final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
- facetFactory.processInvokeOn(processMethodContext);
+ facetFactory.processBulk(processMethodContext);
// then
final BulkFacet facet = facetedMethod.getFacet(BulkFacet.class);
@@ -1337,6 +1360,165 @@ public class ActionAnnotationFacetFactoryTest extends AbstractFacetFactoryJUnit4
}
+ public static class TypeOf extends ActionAnnotationFacetFactoryTest {
+
+ @Test
+ public void whenDeprecatedTypeOfAnnotationOnActionReturningCollection() {
+
+ class Order {
+ }
+ class Customer {
+ @org.apache.isis.applib.annotation.TypeOf(Order.class)
+ public Collection someAction() {
+ return null;
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ actionMethod = findMethod(cls, "someAction");
+
+ // when
+ final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processTypeOf(processMethodContext);
+
+ // then
+ final TypeOfFacet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ Assert.assertNotNull(facet);
+ Assert.assertTrue(facet instanceof TypeOfFacetOnActionForTypeOfAnnotation);
+ assertThat(facet.value(), classEqualTo(Order.class));
+ }
+
+ @Test
+ public void whenDeprecatedTypeOfAnnotationOnActionNotReturningCollection() {
+
+ class Order {
+ }
+ class Customer {
+ @org.apache.isis.applib.annotation.TypeOf(Order.class)
+ public Customer someAction() {
+ return null;
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ actionMethod = findMethod(cls, "someAction");
+
+ // when
+ final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processTypeOf(processMethodContext);
+
+ // then
+ final TypeOfFacet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ Assert.assertNull(facet);
+ }
+
+ @Test
+ public void whenActionAnnotationOnActionReturningCollection() {
+
+ class Order {
+ }
+ class Customer {
+ @Action(typeOf = Order.class)
+ public Collection someAction() {
+ return null;
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ actionMethod = findMethod(cls, "someAction");
+
+ // when
+ final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processTypeOf(processMethodContext);
+
+ // then
+ final TypeOfFacet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ Assert.assertNotNull(facet);
+ Assert.assertTrue(facet instanceof TypeOfFacetForActionAnnotation);
+ assertThat(facet.value(), classEqualTo(Order.class));
+ }
+
+ @Test
+ public void whenActionAnnotationOnActionNotReturningCollection() {
+
+ class Order {
+ }
+ class Customer {
+ @Action(typeOf = Order.class)
+ public Customer someAction() {
+ return null;
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ actionMethod = findMethod(cls, "someAction");
+
+ // when
+ final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processTypeOf(processMethodContext);
+
+ // then
+ final TypeOfFacet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ Assert.assertNull(facet);
+ }
+
+ @Test
+ public void whenInferFromType() {
+
+ class Order {
+ }
+ class Customer {
+ public Order[] someAction() {
+ return null;
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ actionMethod = findMethod(cls, "someAction");
+
+ // when
+ final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processTypeOf(processMethodContext);
+
+ // then
+ final TypeOfFacet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ Assert.assertNotNull(facet);
+ Assert.assertTrue(facet instanceof TypeOfFacetInferredFromArray);
+ assertThat(facet.value(), classEqualTo(Order.class));
+ }
+
+ @Test
+ public void whenInferFromGenerics() {
+
+ class Order {
+ }
+ class Customer {
+ public Collection<Order> someAction() {
+ return null;
+ }
+ }
+
+ // given
+ final Class<?> cls = Customer.class;
+ actionMethod = findMethod(cls, "someAction");
+
+ // when
+ final ProcessMethodContext processMethodContext = new ProcessMethodContext(cls, null, null, actionMethod, mockMethodRemover, facetedMethod);
+ facetFactory.processTypeOf(processMethodContext);
+
+ // then
+ final TypeOfFacet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ Assert.assertNotNull(facet);
+ Assert.assertTrue(facet instanceof TypeOfFacetInferredFromGenerics);
+ assertThat(facet.value(), classEqualTo(Order.class));
+ }
+
+ }
void allowingCommandConfigurationToReturn(final String value) {
context.checking(new Expectations() {
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/collections/collection/CollectionAnnotationFacetFactoryTest_typeOf.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/collections/collection/CollectionAnnotationFacetFactoryTest_typeOf.java b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/collections/collection/CollectionAnnotationFacetFactoryTest_typeOf.java
new file mode 100644
index 0000000..565ecfc
--- /dev/null
+++ b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/collections/collection/CollectionAnnotationFacetFactoryTest_typeOf.java
@@ -0,0 +1,258 @@
+/*
+ * 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 org.apache.isis.core.metamodel.facets.collections.collection;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import org.apache.isis.applib.annotation.TypeOf;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.AbstractFacetFactoryTest;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacet;
+import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacetInferredFromArray;
+import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacetInferredFromGenerics;
+import org.apache.isis.core.metamodel.facets.collections.collection.typeof.TypeOfFacetOnCollectionFromTypeOfAnnotation;
+
+public class CollectionAnnotationFacetFactoryTest_typeOf extends AbstractFacetFactoryTest {
+
+ private CollectionAnnotationFacetFactory facetFactory;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ facetFactory = new CollectionAnnotationFacetFactory();
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ facetFactory = null;
+ super.tearDown();
+ }
+
+ public void testTypeOfFacetInferredForActionWithJavaUtilCollectionReturnType() {
+ class Order {
+ }
+ class Customer {
+ // rawtypes are intention for this test
+ @SuppressWarnings({ "unused", "rawtypes" })
+ @TypeOf(Order.class)
+ public Collection someAction() {
+ return null;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
+ final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
+ assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testTypeOfFacetInferredForCollectionWithJavaUtilCollectionReturnType() {
+ class Order {
+ }
+ class Customer {
+ // rawtypes are intention for this test
+ @SuppressWarnings({ "unused", "rawtypes" })
+ @TypeOf(Order.class)
+ public Collection getOrders() {
+ return null;
+ }
+ }
+ final Method accessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, accessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
+ final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
+ assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testTypeOfFacetInferredForActionWithGenericCollectionReturnType() {
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Collection<Order> someAction() {
+ return null;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetInferredFromGenerics);
+ final TypeOfFacetInferredFromGenerics typeOfFacetInferredFromGenerics = (TypeOfFacetInferredFromGenerics) facet;
+ assertEquals(Order.class, typeOfFacetInferredFromGenerics.value());
+
+ }
+
+ public void testTypeOfFacetInferredForCollectionWithGenericCollectionReturnType() {
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Collection<Order> getOrders() {
+ return null;
+ }
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetInferredFromGenerics);
+ final TypeOfFacetInferredFromGenerics typeOfFacetInferredFromGenerics = (TypeOfFacetInferredFromGenerics) facet;
+ assertEquals(Order.class, typeOfFacetInferredFromGenerics.value());
+
+ }
+
+ public void testTypeOfFacetInferredForActionWithJavaUtilListReturnType() {
+ class Order {
+ }
+ class Customer {
+ // rawTypes is intentional here
+ @SuppressWarnings({ "unused", "rawtypes" })
+ @TypeOf(Order.class)
+ public List someAction() {
+ return null;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
+ final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
+ assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testTypeOfFacetInferredForCollectionWithJavaUtilListReturnType() {
+ class Order {
+ }
+ class Customer {
+ // rawTypes is intentional here
+ @SuppressWarnings({ "unused", "rawtypes" })
+ @TypeOf(Order.class)
+ public List getOrders() {
+ return null;
+ }
+ }
+ final Method accessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, accessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
+ final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
+ assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testTypeOfFacetInferredForActionWithJavaUtilSetReturnType() {
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ @TypeOf(Order.class)
+ public Set someAction() {
+ return null;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
+ final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
+ assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testTypeOfFacetInferredForCollectionWithJavaUtilSetReturnType() {
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ @TypeOf(Order.class)
+ public Set getOrders() {
+ return null;
+ }
+ }
+ final Method accessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, accessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
+ final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
+ assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
+
+ assertNoMethodsRemoved();
+ }
+
+
+ public void testTypeOfFacetIsInferredForCollectionFromOrderArray() {
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Order[] getOrders() {
+ return null;
+ }
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, null, null, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetInferredFromArray);
+ final TypeOfFacetInferredFromArray typeOfFacetInferredFromArray = (TypeOfFacetInferredFromArray) facet;
+ assertEquals(Order.class, typeOfFacetInferredFromArray.value());
+
+ }
+
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/c459aa5e/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/collections/collection/TypeOfAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/collections/collection/TypeOfAnnotationFacetFactoryTest.java b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/collections/collection/TypeOfAnnotationFacetFactoryTest.java
deleted file mode 100644
index 63338ea..0000000
--- a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/facets/collections/collection/TypeOfAnnotationFacetFactoryTest.java
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * 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 org.apache.isis.core.metamodel.facets.collections.collection;
-
-import java.lang.reflect.Method;
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-import org.apache.isis.applib.annotation.TypeOf;
-import org.apache.isis.core.metamodel.facetapi.Facet;
-import org.apache.isis.core.metamodel.facets.AbstractFacetFactoryTest;
-import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
-import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacet;
-import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacetInferredFromArray;
-import org.apache.isis.core.metamodel.facets.actcoll.typeof.TypeOfFacetInferredFromGenerics;
-import org.apache.isis.core.metamodel.facets.collections.collection.typeof.TypeOfFacetOnCollectionFromTypeOfAnnotation;
-
-public class TypeOfAnnotationFacetFactoryTest extends AbstractFacetFactoryTest {
-
- private CollectionAnnotationFacetFactory facetFactory;
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- facetFactory = new CollectionAnnotationFacetFactory();
- }
-
- @Override
- protected void tearDown() throws Exception {
- facetFactory = null;
- super.tearDown();
- }
-
- public void testTypeOfFacetInferredForActionWithJavaUtilCollectionReturnType() {
- class Order {
- }
- class Customer {
- // rawtypes are intention for this test
- @SuppressWarnings({ "unused", "rawtypes" })
- @TypeOf(Order.class)
- public Collection someAction() {
- return null;
- }
- }
- final Method actionMethod = findMethod(Customer.class, "someAction");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
- final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
- assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
-
- assertNoMethodsRemoved();
- }
-
- public void testTypeOfFacetInferredForCollectionWithJavaUtilCollectionReturnType() {
- class Order {
- }
- class Customer {
- // rawtypes are intention for this test
- @SuppressWarnings({ "unused", "rawtypes" })
- @TypeOf(Order.class)
- public Collection getOrders() {
- return null;
- }
- }
- final Method accessorMethod = findMethod(Customer.class, "getOrders");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, accessorMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
- final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
- assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
-
- assertNoMethodsRemoved();
- }
-
- public void testTypeOfFacetInferredForActionWithGenericCollectionReturnType() {
- class Order {
- }
- class Customer {
- @SuppressWarnings("unused")
- public Collection<Order> someAction() {
- return null;
- }
- }
- final Method actionMethod = findMethod(Customer.class, "someAction");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetInferredFromGenerics);
- final TypeOfFacetInferredFromGenerics typeOfFacetInferredFromGenerics = (TypeOfFacetInferredFromGenerics) facet;
- assertEquals(Order.class, typeOfFacetInferredFromGenerics.value());
-
- }
-
- public void testTypeOfFacetInferredForCollectionWithGenericCollectionReturnType() {
- class Order {
- }
- class Customer {
- @SuppressWarnings("unused")
- public Collection<Order> getOrders() {
- return null;
- }
- }
- final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, collectionAccessorMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetInferredFromGenerics);
- final TypeOfFacetInferredFromGenerics typeOfFacetInferredFromGenerics = (TypeOfFacetInferredFromGenerics) facet;
- assertEquals(Order.class, typeOfFacetInferredFromGenerics.value());
-
- }
-
- public void testTypeOfFacetInferredForActionWithJavaUtilListReturnType() {
- class Order {
- }
- class Customer {
- // rawTypes is intentional here
- @SuppressWarnings({ "unused", "rawtypes" })
- @TypeOf(Order.class)
- public List someAction() {
- return null;
- }
- }
- final Method actionMethod = findMethod(Customer.class, "someAction");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
- final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
- assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
-
- assertNoMethodsRemoved();
- }
-
- public void testTypeOfFacetInferredForCollectionWithJavaUtilListReturnType() {
- class Order {
- }
- class Customer {
- // rawTypes is intentional here
- @SuppressWarnings({ "unused", "rawtypes" })
- @TypeOf(Order.class)
- public List getOrders() {
- return null;
- }
- }
- final Method accessorMethod = findMethod(Customer.class, "getOrders");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, accessorMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
- final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
- assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
-
- assertNoMethodsRemoved();
- }
-
- public void testTypeOfFacetInferredForActionWithJavaUtilSetReturnType() {
- class Order {
- }
- class Customer {
- @SuppressWarnings("unused")
- @TypeOf(Order.class)
- public Set someAction() {
- return null;
- }
- }
- final Method actionMethod = findMethod(Customer.class, "someAction");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
- final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
- assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
-
- assertNoMethodsRemoved();
- }
-
- public void testTypeOfFacetInferredForCollectionWithJavaUtilSetReturnType() {
- class Order {
- }
- class Customer {
- @SuppressWarnings("unused")
- @TypeOf(Order.class)
- public Set getOrders() {
- return null;
- }
- }
- final Method accessorMethod = findMethod(Customer.class, "getOrders");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, accessorMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetOnCollectionFromTypeOfAnnotation);
- final TypeOfFacetOnCollectionFromTypeOfAnnotation typeOfFacetOnCollectionAnnotation = (TypeOfFacetOnCollectionFromTypeOfAnnotation) facet;
- assertEquals(Order.class, typeOfFacetOnCollectionAnnotation.value());
-
- assertNoMethodsRemoved();
- }
-
- public void testTypeOfFacetInferredForActionWithArrayReturnType() {
- class Order {
- }
- class Customer {
- @SuppressWarnings("unused")
- public Order[] someAction() {
- return null;
- }
- }
- final Method actionMethod = findMethod(Customer.class, "someAction");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetInferredFromArray);
- final TypeOfFacetInferredFromArray typeOfFacetInferredFromArray = (TypeOfFacetInferredFromArray) facet;
- assertEquals(Order.class, typeOfFacetInferredFromArray.value());
-
- assertNoMethodsRemoved();
- }
-
- public void testTypeOfFacetIsInferredForCollectionFromOrderArray() {
- class Order {
- }
- class Customer {
- @SuppressWarnings("unused")
- public Order[] getOrders() {
- return null;
- }
- }
- final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, collectionAccessorMethod, methodRemover, facetedMethod));
-
- final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
- assertNotNull(facet);
- assertTrue(facet instanceof TypeOfFacetInferredFromArray);
- final TypeOfFacetInferredFromArray typeOfFacetInferredFromArray = (TypeOfFacetInferredFromArray) facet;
- assertEquals(Order.class, typeOfFacetInferredFromArray.value());
-
- }
-
- public void testTypeOfAnnotationIgnoredForActionIfReturnTypeIsntACollectionType() {
- class Order {
- }
- class Customer {
- @SuppressWarnings("unused")
- @TypeOf(Order.class)
- public Customer someAction() {
- return null;
- }
- }
- final Method actionMethod = findMethod(Customer.class, "someAction");
-
- facetFactory.process(new ProcessMethodContext(Customer.class, null, null, actionMethod, methodRemover, facetedMethod));
-
- assertNull(facetedMethod.getFacet(TypeOfFacet.class));
-
- assertNoMethodsRemoved();
- }
-
-}