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 2012/12/05 00:41:12 UTC
[44/52] [partial] ISIS-188: consolidating isis-core
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/ActionSemanticsFallbackFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/ActionSemanticsFallbackFacetFactoryTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/ActionSemanticsFallbackFacetFactoryTest.java
new file mode 100644
index 0000000..8f2011c
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/ActionSemanticsFallbackFacetFactoryTest.java
@@ -0,0 +1,90 @@
+/*
+ * 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.progmodel.facets.actions.semantics;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.assertThat;
+
+import java.lang.reflect.Method;
+
+import org.apache.isis.applib.annotation.ActionSemantics;
+import org.apache.isis.applib.annotation.ActionSemantics.Of;
+import org.apache.isis.applib.annotation.Debug;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.actions.debug.DebugFacet;
+import org.apache.isis.core.metamodel.facets.actions.semantics.ActionSemanticsFacet;
+import org.apache.isis.core.progmodel.facets.AbstractFacetFactoryTest;
+import org.apache.isis.core.progmodel.facets.actions.debug.annotation.DebugAnnotationFacetFactory;
+
+public class ActionSemanticsFallbackFacetFactoryTest extends AbstractFacetFactoryTest {
+
+ private ActionSemanticsFallbackFacetFactory facetFactory;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ facetFactory = new ActionSemanticsFallbackFacetFactory();
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ facetFactory = null;
+ super.tearDown();
+ }
+
+ public void testNoFallbackAppliedIfFacetAlreadyExistsPickedUp() {
+ class Customer {
+ @SuppressWarnings("unused")
+ public void someAction() {
+ }
+ }
+ final Facet existing = new ActionSemanticsFacetAnnotation(ActionSemantics.Of.SAFE, facetedMethod);
+ facetedMethod.addFacet(existing);
+
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(ActionSemanticsFacet.class);
+ assertThat(facet, is(existing));
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testNoAnnotationPickedUp() {
+ class Customer {
+ @SuppressWarnings("unused")
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(ActionSemanticsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof ActionSemanticsFacetFallbackToNonIdempotent);
+
+ assertNoMethodsRemoved();
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/IdempotentAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/IdempotentAnnotationFacetFactoryTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/IdempotentAnnotationFacetFactoryTest.java
new file mode 100644
index 0000000..2b44991
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/IdempotentAnnotationFacetFactoryTest.java
@@ -0,0 +1,86 @@
+/*
+ * 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.progmodel.facets.actions.semantics;
+
+import java.lang.reflect.Method;
+
+import org.apache.isis.applib.annotation.ActionSemantics;
+import org.apache.isis.applib.annotation.Idempotent;
+import org.apache.isis.applib.annotation.QueryOnly;
+import org.apache.isis.applib.annotation.ActionSemantics.Of;
+import org.apache.isis.applib.annotation.Debug;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.actions.debug.DebugFacet;
+import org.apache.isis.core.metamodel.facets.actions.semantics.ActionSemanticsFacet;
+import org.apache.isis.core.progmodel.facets.AbstractFacetFactoryTest;
+import org.apache.isis.core.progmodel.facets.actions.debug.annotation.DebugAnnotationFacetFactory;
+
+public class IdempotentAnnotationFacetFactoryTest extends AbstractFacetFactoryTest {
+
+ private IdempotentAnnotationFacetFactory facetFactory;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ facetFactory = new IdempotentAnnotationFacetFactory();
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ facetFactory = null;
+ super.tearDown();
+ }
+
+ public void testQueryOnlyAnnotationPickedUp() {
+ class Customer {
+ @Idempotent
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(ActionSemanticsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof IdempotentFacetAnnotation);
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testNoAnnotationPickedUp() {
+ class Customer {
+ @SuppressWarnings("unused")
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(ActionSemanticsFacet.class);
+ assertNull(facet);
+
+ assertNoMethodsRemoved();
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/QueryOnlyAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/QueryOnlyAnnotationFacetFactoryTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/QueryOnlyAnnotationFacetFactoryTest.java
new file mode 100644
index 0000000..05bcade
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/actions/semantics/QueryOnlyAnnotationFacetFactoryTest.java
@@ -0,0 +1,85 @@
+/*
+ * 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.progmodel.facets.actions.semantics;
+
+import java.lang.reflect.Method;
+
+import org.apache.isis.applib.annotation.ActionSemantics;
+import org.apache.isis.applib.annotation.QueryOnly;
+import org.apache.isis.applib.annotation.ActionSemantics.Of;
+import org.apache.isis.applib.annotation.Debug;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.actions.debug.DebugFacet;
+import org.apache.isis.core.metamodel.facets.actions.semantics.ActionSemanticsFacet;
+import org.apache.isis.core.progmodel.facets.AbstractFacetFactoryTest;
+import org.apache.isis.core.progmodel.facets.actions.debug.annotation.DebugAnnotationFacetFactory;
+
+public class QueryOnlyAnnotationFacetFactoryTest extends AbstractFacetFactoryTest {
+
+ private QueryOnlyAnnotationFacetFactory facetFactory;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ facetFactory = new QueryOnlyAnnotationFacetFactory();
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ facetFactory = null;
+ super.tearDown();
+ }
+
+ public void testQueryOnlyAnnotationPickedUp() {
+ class Customer {
+ @QueryOnly
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(ActionSemanticsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof QueryOnlyFacetAnnotation);
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testNoAnnotationPickedUp() {
+ class Customer {
+ @SuppressWarnings("unused")
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(ActionSemanticsFacet.class);
+ assertNull(facet);
+
+ assertNoMethodsRemoved();
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/collections/CollectionFieldMethodsFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/collections/CollectionFieldMethodsFacetFactoryTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/collections/CollectionFieldMethodsFacetFactoryTest.java
new file mode 100644
index 0000000..671754c
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/collections/CollectionFieldMethodsFacetFactoryTest.java
@@ -0,0 +1,764 @@
+/*
+ * 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.progmodel.facets.collections;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.isis.applib.annotation.When;
+import org.apache.isis.applib.security.UserMemento;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.accessor.PropertyOrCollectionAccessorFacet;
+import org.apache.isis.core.metamodel.facets.collections.modify.CollectionAddToFacet;
+import org.apache.isis.core.metamodel.facets.collections.modify.CollectionClearFacet;
+import org.apache.isis.core.metamodel.facets.collections.modify.CollectionRemoveFromFacet;
+import org.apache.isis.core.metamodel.facets.describedas.DescribedAsFacet;
+import org.apache.isis.core.metamodel.facets.hide.HiddenFacet;
+import org.apache.isis.core.metamodel.facets.named.NamedFacet;
+import org.apache.isis.core.metamodel.facets.typeof.TypeOfFacet;
+import org.apache.isis.core.progmodel.facets.AbstractFacetFactoryTest;
+import org.apache.isis.core.progmodel.facets.collections.accessor.CollectionAccessorFacetFactory;
+import org.apache.isis.core.progmodel.facets.collections.accessor.CollectionAccessorFacetViaAccessor;
+import org.apache.isis.core.progmodel.facets.collections.clear.CollectionClearFacetFactory;
+import org.apache.isis.core.progmodel.facets.collections.clear.CollectionClearFacetViaAccessor;
+import org.apache.isis.core.progmodel.facets.collections.clear.CollectionClearFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.collections.modify.CollectionAddRemoveAndValidateFacetFactory;
+import org.apache.isis.core.progmodel.facets.collections.modify.CollectionAddToFacetViaAccessor;
+import org.apache.isis.core.progmodel.facets.collections.modify.CollectionAddToFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.collections.modify.CollectionRemoveFromFacetViaAccessor;
+import org.apache.isis.core.progmodel.facets.collections.modify.CollectionRemoveFromFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.collections.modify.TypeOfFacetInferredFromSupportingMethods;
+import org.apache.isis.core.progmodel.facets.collections.validate.CollectionValidateAddToFacet;
+import org.apache.isis.core.progmodel.facets.collections.validate.CollectionValidateAddToFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.collections.validate.CollectionValidateRemoveFromFacet;
+import org.apache.isis.core.progmodel.facets.collections.validate.CollectionValidateRemoveFromFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.members.describedas.staticmethod.DescribedAsFacetViaDescriptionMethodFacetFactory;
+import org.apache.isis.core.progmodel.facets.members.describedas.staticmethod.DescribedAsFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.members.disabled.DisableForSessionFacet;
+import org.apache.isis.core.progmodel.facets.members.disabled.DisabledFacet;
+import org.apache.isis.core.progmodel.facets.members.disabled.forsession.DisableForSessionFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.members.disabled.forsession.DisabledFacetViaDisableForSessionMethodFacetFactory;
+import org.apache.isis.core.progmodel.facets.members.disabled.staticmethod.DisabledFacetAlwaysEverywhere;
+import org.apache.isis.core.progmodel.facets.members.disabled.staticmethod.DisabledFacetViaProtectMethodFacetFactory;
+import org.apache.isis.core.progmodel.facets.members.hidden.HiddenFacetAbstract;
+import org.apache.isis.core.progmodel.facets.members.hidden.HideForSessionFacet;
+import org.apache.isis.core.progmodel.facets.members.hidden.forsession.HiddenFacetViaHideForSessionMethodFacetFactory;
+import org.apache.isis.core.progmodel.facets.members.hidden.forsession.HideForSessionFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.members.hidden.staticmethod.HiddenFacetAlwaysEverywhere;
+import org.apache.isis.core.progmodel.facets.members.hidden.staticmethod.HiddenFacetViaAlwaysHideMethodFacetFactory;
+import org.apache.isis.core.progmodel.facets.members.named.staticmethod.NamedFacetViaMethod;
+import org.apache.isis.core.progmodel.facets.members.named.staticmethod.NamedFacetViaNameMethodFacetFactory;
+
+public class CollectionFieldMethodsFacetFactoryTest extends AbstractFacetFactoryTest {
+
+ public void testPropertyAccessorFacetIsInstalledForJavaUtilCollectionAndMethodRemoved() {
+ final CollectionAccessorFacetFactory facetFactory = new CollectionAccessorFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ class Customer {
+ @SuppressWarnings({ "rawtypes", "unused" })
+ public Collection getOrders() {
+ return null;
+ }
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(PropertyOrCollectionAccessorFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionAccessorFacetViaAccessor);
+ final CollectionAccessorFacetViaAccessor propertyAccessorFacetViaAccessor = (CollectionAccessorFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, propertyAccessorFacetViaAccessor.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(collectionAccessorMethod));
+ }
+
+ public void testPropertyAccessorFacetIsInstalledForJavaUtilListAndMethodRemoved() {
+ final CollectionAccessorFacetFactory facetFactory = new CollectionAccessorFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ class Customer {
+ @SuppressWarnings({ "rawtypes", "unused" })
+ public List getOrders() {
+ return null;
+ }
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(PropertyOrCollectionAccessorFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionAccessorFacetViaAccessor);
+ final CollectionAccessorFacetViaAccessor propertyAccessorFacetViaAccessor = (CollectionAccessorFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, propertyAccessorFacetViaAccessor.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(collectionAccessorMethod));
+ }
+
+ public void testPropertyAccessorFacetIsInstalledForJavaUtilSetAndMethodRemoved() {
+ final CollectionAccessorFacetFactory facetFactory = new CollectionAccessorFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ class Customer {
+ @SuppressWarnings({ "rawtypes", "unused" })
+ public Set getOrders() {
+ return null;
+ }
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(PropertyOrCollectionAccessorFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionAccessorFacetViaAccessor);
+ final CollectionAccessorFacetViaAccessor propertyAccessorFacetViaAccessor = (CollectionAccessorFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, propertyAccessorFacetViaAccessor.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(collectionAccessorMethod));
+ }
+
+ public void testPropertyAccessorFacetIsInstalledForObjectArrayAndMethodRemoved() {
+ final CollectionAccessorFacetFactory facetFactory = new CollectionAccessorFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ class Customer {
+ @SuppressWarnings("unused")
+ public Object[] getOrders() {
+ return null;
+ }
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(PropertyOrCollectionAccessorFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionAccessorFacetViaAccessor);
+ final CollectionAccessorFacetViaAccessor propertyAccessorFacetViaAccessor = (CollectionAccessorFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, propertyAccessorFacetViaAccessor.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(collectionAccessorMethod));
+ }
+
+ public void testPropertyAccessorFacetIsInstalledForOrderArrayAndMethodRemoved() {
+ final CollectionAccessorFacetFactory facetFactory = new CollectionAccessorFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Order[] getOrders() {
+ return null;
+ }
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(PropertyOrCollectionAccessorFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionAccessorFacetViaAccessor);
+ final CollectionAccessorFacetViaAccessor propertyAccessorFacetViaAccessor = (CollectionAccessorFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, propertyAccessorFacetViaAccessor.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(collectionAccessorMethod));
+ }
+
+ public void testAddToFacetIsInstalledViaAccessorIfNoExplicitAddToMethodExists() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ 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, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionAddToFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionAddToFacetViaAccessor);
+ final CollectionAddToFacetViaAccessor collectionAddToFacetViaAccessor = (CollectionAddToFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, collectionAddToFacetViaAccessor.getMethods().get(0));
+ }
+
+ public void testCannotInferTypeOfFacetIfNoExplicitAddToOrRemoveFromMethods() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ 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, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ assertNull(facetedMethod.getFacet(TypeOfFacet.class));
+ }
+
+ public void testRemoveFromFacetIsInstalledViaAccessorIfNoExplicitRemoveFromMethodExists() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ 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, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionRemoveFromFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionRemoveFromFacetViaAccessor);
+ final CollectionRemoveFromFacetViaAccessor collectionRemoveFromFacetViaAccessor = (CollectionRemoveFromFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, collectionRemoveFromFacetViaAccessor.getMethods().get(0));
+ }
+
+ public void testAddToFacetIsInstalledAndMethodRemoved() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Collection<Order> getOrders() {
+ return null;
+ }
+
+ @SuppressWarnings("unused")
+ public void addToOrders(final Order o) {
+ };
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+ final Method addToMethod = findMethod(Customer.class, "addToOrders", new Class[] { Order.class });
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionAddToFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionAddToFacetViaMethod);
+ final CollectionAddToFacetViaMethod collectionAddToFacetViaMethod = (CollectionAddToFacetViaMethod) facet;
+ assertEquals(addToMethod, collectionAddToFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(addToMethod));
+ }
+
+ public void testCanInferTypeOfFacetFromExplicitAddToMethod() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Collection<Order> getOrders() {
+ return null;
+ }
+
+ @SuppressWarnings("unused")
+ public void addToOrders(final Order o) {
+ };
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetInferredFromSupportingMethods);
+ final TypeOfFacetInferredFromSupportingMethods typeOfFacetInferredFromSupportingMethods = (TypeOfFacetInferredFromSupportingMethods) facet;
+ assertEquals(Order.class, typeOfFacetInferredFromSupportingMethods.value());
+ }
+
+ public void testRemoveFromFacetIsInstalledAndMethodRemoved() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings({ "rawtypes", "unused" })
+ public Collection getOrders() {
+ return null;
+ }
+
+ @SuppressWarnings("unused")
+ public void removeFromOrders(final Order o) {
+ };
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+ final Method removeFromMethod = findMethod(Customer.class, "removeFromOrders", new Class[] { Order.class });
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionRemoveFromFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionRemoveFromFacetViaMethod);
+ final CollectionRemoveFromFacetViaMethod collectionRemoveFromFacetViaMethod = (CollectionRemoveFromFacetViaMethod) facet;
+ assertEquals(removeFromMethod, collectionRemoveFromFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(removeFromMethod));
+ }
+
+ public void testCanInferTypeOfFacetFromExplicitRemoveFromMethod() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Collection<Order> getOrders() {
+ return null;
+ };
+
+ @SuppressWarnings("unused")
+ public void removeFromOrders(final Order o) {
+ };
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(TypeOfFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof TypeOfFacetInferredFromSupportingMethods);
+ final TypeOfFacetInferredFromSupportingMethods typeOfFacetInferredFromSupportingMethods = (TypeOfFacetInferredFromSupportingMethods) facet;
+ assertEquals(Order.class, typeOfFacetInferredFromSupportingMethods.value());
+ }
+
+ public void testClearFacetIsInstalledAndMethodRemoved() {
+ final CollectionClearFacetFactory facetFactory = new CollectionClearFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings({ "hiding", "unused" })
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings({ "rawtypes", "unused" })
+ public Collection getOrders() {
+ return null;
+ }
+
+ @SuppressWarnings("unused")
+ public void clearOrders() {
+ };
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+ final Method clearMethod = findMethod(Customer.class, "clearOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionClearFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionClearFacetViaMethod);
+ final CollectionClearFacetViaMethod collectionClearFacetViaMethod = (CollectionClearFacetViaMethod) facet;
+ assertEquals(clearMethod, collectionClearFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(clearMethod));
+ }
+
+ public void testClearFacetIsInstalledViaAccessorIfNoExplicitClearMethod() {
+ final CollectionClearFacetFactory facetFactory = new CollectionClearFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings({ "hiding", "unused" })
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings({ "rawtypes", "unused" })
+ public Collection getOrders() {
+ return null;
+ }
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionClearFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionClearFacetViaAccessor);
+ final CollectionClearFacetViaAccessor collectionClearFacetViaAccessor = (CollectionClearFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, collectionClearFacetViaAccessor.getMethods().get(0));
+ }
+
+ public void testValidateAddToFacetIsInstalledAndMethodRemoved() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings({ "rawtypes", "unused" })
+ public Collection getOrders() {
+ return null;
+ }
+
+ @SuppressWarnings("unused")
+ public void addToOrders(final Order o) {
+ };
+
+ @SuppressWarnings("unused")
+ public String validateAddToOrders(final Order o) {
+ return null;
+ };
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+ final Method validateAddToMethod = findMethod(Customer.class, "validateAddToOrders", new Class[] { Order.class });
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionValidateAddToFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionValidateAddToFacetViaMethod);
+ final CollectionValidateAddToFacetViaMethod collectionValidateAddToFacetViaMethod = (CollectionValidateAddToFacetViaMethod) facet;
+ assertEquals(validateAddToMethod, collectionValidateAddToFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(validateAddToMethod));
+ }
+
+ public void testValidateRemoveFromFacetIsInstalledAndMethodRemoved() {
+ final CollectionAddRemoveAndValidateFacetFactory facetFactory = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Collection<Order> getOrders() {
+ return null;
+ }
+
+ @SuppressWarnings("unused")
+ public void removeFromOrders(final Order o) {
+ };
+
+ @SuppressWarnings("unused")
+ public String validateRemoveFromOrders(final Order o) {
+ return null;
+ };
+ }
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+ final Method validateRemoveFromMethod = findMethod(Customer.class, "validateRemoveFromOrders", new Class[] { Order.class });
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionValidateRemoveFromFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionValidateRemoveFromFacetViaMethod);
+ final CollectionValidateRemoveFromFacetViaMethod collectionValidateRemoveFromFacetViaMethod = (CollectionValidateRemoveFromFacetViaMethod) facet;
+ assertEquals(validateRemoveFromMethod, collectionValidateRemoveFromFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(validateRemoveFromMethod));
+ }
+
+ public void testMethodFoundInSuperclass() {
+ final CollectionAccessorFacetFactory facetFactory = new CollectionAccessorFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Collection<Order> getOrders() {
+ return null;
+ }
+ }
+
+ class CustomerEx extends Customer {
+ }
+
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerEx.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(PropertyOrCollectionAccessorFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionAccessorFacetViaAccessor);
+ final CollectionAccessorFacetViaAccessor collectionAccessorFacetViaMethod = (CollectionAccessorFacetViaAccessor) facet;
+ assertEquals(collectionAccessorMethod, collectionAccessorFacetViaMethod.getMethods().get(0));
+ }
+
+ public void testMethodFoundInSuperclassButHelpeMethodsFoundInSubclasses() {
+ final CollectionAccessorFacetFactory facetFactoryForAccessor = new CollectionAccessorFacetFactory();
+ facetFactoryForAccessor.setSpecificationLookup(reflector);
+ final CollectionAddRemoveAndValidateFacetFactory facetFactoryForHelpers = new CollectionAddRemoveAndValidateFacetFactory();
+ facetFactoryForHelpers.setSpecificationLookup(reflector);
+
+ @SuppressWarnings("hiding")
+ class Order {
+ }
+ class Customer {
+ @SuppressWarnings("unused")
+ public Collection<Order> getOrders() {
+ return null;
+ }
+ }
+
+ class CustomerEx extends Customer {
+ @SuppressWarnings("unused")
+ public void removeFromOrders(final Order o) {
+ };
+
+ @SuppressWarnings("unused")
+ public String validateRemoveFromOrders(final Order o) {
+ return null;
+ };
+ }
+
+ final Method collectionAccessorMethod = findMethod(Customer.class, "getOrders");
+ final Method removeFromMethod = findMethod(CustomerEx.class, "removeFromOrders", new Class[] { Order.class });
+ final Method validateRemoveFromMethod = findMethod(CustomerEx.class, "validateRemoveFromOrders", new Class[] { Order.class });
+
+ facetFactoryForAccessor.process(new ProcessMethodContext(CustomerEx.class, collectionAccessorMethod, methodRemover, facetedMethod));
+ facetFactoryForHelpers.process(new ProcessMethodContext(CustomerEx.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(CollectionRemoveFromFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof CollectionRemoveFromFacetViaMethod);
+ final CollectionRemoveFromFacetViaMethod collectionRemoveFromFacetViaMethod = (CollectionRemoveFromFacetViaMethod) facet;
+ assertEquals(removeFromMethod, collectionRemoveFromFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(removeFromMethod));
+
+ final Facet facet1 = facetedMethod.getFacet(CollectionValidateRemoveFromFacet.class);
+ assertNotNull(facet1);
+ assertTrue(facet1 instanceof CollectionValidateRemoveFromFacetViaMethod);
+ final CollectionValidateRemoveFromFacetViaMethod collectionValidateRemoveFromFacetViaMethod = (CollectionValidateRemoveFromFacetViaMethod) facet1;
+ assertEquals(validateRemoveFromMethod, collectionValidateRemoveFromFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(validateRemoveFromMethod));
+ }
+
+ static class Order {
+ }
+
+ public static class CustomerStatic {
+ public Collection<Order> getOrders() {
+ return null;
+ }
+
+ public static String nameOrders() {
+ return "Most Recent Orders";
+ };
+
+ public static String descriptionOrders() {
+ return "Some old description";
+ }
+
+ public static boolean alwaysHideOrders() {
+ return true;
+ }
+
+ public static boolean protectOrders() {
+ return true;
+ }
+
+ public static boolean hideOrders(final UserMemento userMemento) {
+ return true;
+ }
+
+ public static String disableOrders(final UserMemento userMemento) {
+ return "disabled for this user";
+ }
+
+ public static void getOtherOrders() {
+ }
+
+ public static boolean alwaysHideOtherOrders() {
+ return false;
+ }
+
+ public static boolean protectOtherOrders() {
+ return false;
+ }
+ }
+
+ public void testInstallsNamedFacetUsingNameMethodAndRemovesMethod() {
+ final NamedFacetViaNameMethodFacetFactory facetFactory = new NamedFacetViaNameMethodFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ final Method collectionAccessorMethod = findMethod(CustomerStatic.class, "getOrders");
+ final Method nameMethod = findMethod(CustomerStatic.class, "nameOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(NamedFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof NamedFacetViaMethod);
+ final NamedFacetViaMethod namedFacet = (NamedFacetViaMethod) facet;
+ assertEquals("Most Recent Orders", namedFacet.value());
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(nameMethod));
+ }
+
+ public void testInstallsDescribedAsFacetUsingDescriptionAndRemovesMethod() {
+ final DescribedAsFacetViaDescriptionMethodFacetFactory facetFactory = new DescribedAsFacetViaDescriptionMethodFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ final Method collectionAccessorMethod = findMethod(CustomerStatic.class, "getOrders");
+ final Method descriptionMethod = findMethod(CustomerStatic.class, "descriptionOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DescribedAsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DescribedAsFacetViaMethod);
+ final DescribedAsFacetViaMethod describedAsFacet = (DescribedAsFacetViaMethod) facet;
+ assertEquals("Some old description", describedAsFacet.value());
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(descriptionMethod));
+ }
+
+ public void testInstallsHiddenFacetUsingAlwaysHideAndRemovesMethod() {
+ final HiddenFacetViaAlwaysHideMethodFacetFactory facetFactory = new HiddenFacetViaAlwaysHideMethodFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ final Method collectionAccessorMethod = findMethod(CustomerStatic.class, "getOrders");
+ final Method alwaysHideMethod = findMethod(CustomerStatic.class, "alwaysHideOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof HiddenFacetAlwaysEverywhere);
+ final HiddenFacetAbstract hiddenFacetAlways = (HiddenFacetAlwaysEverywhere) facet;
+ assertEquals(When.ALWAYS, hiddenFacetAlways.when());
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(alwaysHideMethod));
+ }
+
+ public void testInstallsHiddenFacetUsingAlwaysHideWhenNotAndRemovesMethod() {
+ final HiddenFacetViaAlwaysHideMethodFacetFactory facetFactory = new HiddenFacetViaAlwaysHideMethodFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ final Method collectionAccessorMethod = findMethod(CustomerStatic.class, "getOtherOrders");
+ final Method alwaysHideMethod = findMethod(CustomerStatic.class, "alwaysHideOtherOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ assertNull(facetedMethod.getFacet(HiddenFacet.class));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(alwaysHideMethod));
+ }
+
+ public void testInstallsDisabledFacetUsingProtectAndRemovesMethod() {
+ final DisabledFacetViaProtectMethodFacetFactory facetFactory = new DisabledFacetViaProtectMethodFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ final Method collectionAccessorMethod = findMethod(CustomerStatic.class, "getOrders");
+ final Method protectMethod = findMethod(CustomerStatic.class, "protectOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DisabledFacetAlwaysEverywhere);
+ final DisabledFacetAlwaysEverywhere disabledFacetAlways = (DisabledFacetAlwaysEverywhere) facet;
+ assertEquals(When.ALWAYS, disabledFacetAlways.when());
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(protectMethod));
+ }
+
+ public void testDoesNotInstallDisabledFacetUsingProtectWhenNotAndRemovesMethod() {
+ final DisabledFacetViaProtectMethodFacetFactory facetFactory = new DisabledFacetViaProtectMethodFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ final Method collectionAccessorMethod = findMethod(CustomerStatic.class, "getOtherOrders");
+ final Method protectMethod = findMethod(CustomerStatic.class, "protectOtherOrders");
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ assertNull(facetedMethod.getFacet(DisabledFacet.class));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(protectMethod));
+ }
+
+ public void testInstallsHiddenForSessionFacetAndRemovesMethod() {
+ final HiddenFacetViaHideForSessionMethodFacetFactory facetFactory = new HiddenFacetViaHideForSessionMethodFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ final Method collectionAccessorMethod = findMethod(CustomerStatic.class, "getOrders");
+ final Method hideMethod = findMethod(CustomerStatic.class, "hideOrders", new Class[] { UserMemento.class });
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HideForSessionFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof HideForSessionFacetViaMethod);
+ final HideForSessionFacetViaMethod hideForSessionFacetViaMethod = (HideForSessionFacetViaMethod) facet;
+ assertEquals(hideMethod, hideForSessionFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(hideMethod));
+ }
+
+ public void testInstallsDisabledForSessionFacetAndRemovesMethod() {
+ final DisabledFacetViaDisableForSessionMethodFacetFactory facetFactory = new DisabledFacetViaDisableForSessionMethodFacetFactory();
+ facetFactory.setSpecificationLookup(reflector);
+
+ final Method collectionAccessorMethod = findMethod(CustomerStatic.class, "getOrders");
+ final Method disableMethod = findMethod(CustomerStatic.class, "disableOrders", new Class[] { UserMemento.class });
+
+ facetFactory.process(new ProcessMethodContext(CustomerStatic.class, collectionAccessorMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisableForSessionFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DisableForSessionFacetViaMethod);
+ final DisableForSessionFacetViaMethod disableForSessionFacetViaMethod = (DisableForSessionFacetViaMethod) facet;
+ assertEquals(disableMethod, disableForSessionFacetViaMethod.getMethods().get(0));
+
+ assertTrue(methodRemover.getRemovedMethodMethodCalls().contains(disableMethod));
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/collections/JavaCollectionFacetTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/collections/JavaCollectionFacetTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/collections/JavaCollectionFacetTest.java
new file mode 100644
index 0000000..6e1dfeb
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/collections/JavaCollectionFacetTest.java
@@ -0,0 +1,93 @@
+/*
+ * 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.progmodel.facets.collections;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertThat;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.jmock.Expectations;
+import org.jmock.auto.Mock;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import org.apache.isis.core.metamodel.adapter.ObjectAdapter;
+import org.apache.isis.core.metamodel.adapter.mgr.AdapterManager;
+import org.apache.isis.core.metamodel.facetapi.FacetHolder;
+import org.apache.isis.core.progmodel.facets.collections.collection.JavaCollectionFacet;
+import org.apache.isis.core.testsupport.jmock.JUnitRuleMockery2;
+import org.apache.isis.core.testsupport.jmock.JUnitRuleMockery2.Mode;
+
+public class JavaCollectionFacetTest {
+
+ private JavaCollectionFacet facet;
+
+ @Rule
+ public JUnitRuleMockery2 context = JUnitRuleMockery2.createFor(Mode.INTERFACES_AND_CLASSES);
+
+ @Mock
+ private FacetHolder mockFacetHolder;
+ @Mock
+ private ObjectAdapter mockCollection;
+ @Mock
+ private Collection<ObjectAdapter> mockWrappedCollection;
+ @Mock
+ private Iterator<ObjectAdapter> mockIterator;
+ @Mock
+ private AdapterManager mockAdapterManager;
+
+ @Before
+ public void setUp() throws Exception {
+ mockAdapterManager = context.mock(AdapterManager.class);
+
+ facet = new JavaCollectionFacet(mockFacetHolder, mockAdapterManager);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ facet = null;
+ }
+
+ @Test
+ public void firstElementForEmptyCollectionIsNull() {
+ context.checking(new Expectations() {
+ {
+ one(mockCollection).getObject();
+ will(returnValue(mockWrappedCollection));
+
+ one(mockWrappedCollection).size();
+ will(returnValue(0));
+
+ one(mockWrappedCollection).iterator();
+ will(returnValue(mockIterator));
+
+ one(mockIterator).hasNext();
+ will(returnValue(false));
+ }
+ });
+ assertThat(facet.firstElement(mockCollection), is(nullValue()));
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/disabled/DisabledAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/disabled/DisabledAnnotationFacetFactoryTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/disabled/DisabledAnnotationFacetFactoryTest.java
new file mode 100644
index 0000000..ab031b3
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/disabled/DisabledAnnotationFacetFactoryTest.java
@@ -0,0 +1,207 @@
+/*
+ * 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.progmodel.facets.disabled;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+
+import org.apache.isis.applib.annotation.Disabled;
+import org.apache.isis.applib.annotation.When;
+import org.apache.isis.applib.annotation.Where;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.progmodel.facets.AbstractFacetFactoryTest;
+import org.apache.isis.core.progmodel.facets.members.disabled.DisabledFacet;
+import org.apache.isis.core.progmodel.facets.members.disabled.DisabledFacetAbstract;
+import org.apache.isis.core.progmodel.facets.members.disabled.annotation.DisabledAnnotationFacetFactory;
+
+public class DisabledAnnotationFacetFactoryTest extends AbstractFacetFactoryTest {
+
+ private DisabledAnnotationFacetFactory facetFactory;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ facetFactory = new DisabledAnnotationFacetFactory();
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ facetFactory = null;
+ super.tearDown();
+ }
+
+ public void testDisabledAnnotationPickedUpOnProperty() {
+ class Customer {
+ @Disabled
+ public int getNumberOfOrders() {
+ return 0;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "getNumberOfOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DisabledFacetAbstract);
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testDisabledAnnotationPickedUpOnCollection() {
+ class Customer {
+ @Disabled
+ public Collection<?> getOrders() {
+ return null;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DisabledFacetAbstract);
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testDisabledAnnotationPickedUpOnAction() {
+ class Customer {
+ @Disabled
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DisabledFacetAbstract);
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testDisabledWhenAlwaysAnnotationPickedUpOn() {
+ class Customer {
+ @Disabled(when = When.ALWAYS)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ final DisabledFacetAbstract disabledFacetAbstract = (DisabledFacetAbstract) facet;
+
+ assertEquals(When.ALWAYS, disabledFacetAbstract.when());
+ }
+
+ public void testDisabledWhenNeverAnnotationPickedUpOn() {
+ class Customer {
+ @Disabled(when = When.NEVER)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ final DisabledFacetAbstract disabledFacetAbstract = (DisabledFacetAbstract) facet;
+
+ assertEquals(When.NEVER, disabledFacetAbstract.when());
+ }
+
+ public void testDisabledWhenOncePersistedAnnotationPickedUpOn() {
+ class Customer {
+ @Disabled(when = When.ONCE_PERSISTED)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ final DisabledFacetAbstract disabledFacetAbstract = (DisabledFacetAbstract) facet;
+
+ assertEquals(When.ONCE_PERSISTED, disabledFacetAbstract.when());
+ }
+
+ public void testDisabledWhenUntilPersistedAnnotationPickedUpOn() {
+ class Customer {
+ @Disabled(when = When.UNTIL_PERSISTED)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ final DisabledFacetAbstract disabledFacetAbstract = (DisabledFacetAbstract) facet;
+
+ assertEquals(When.UNTIL_PERSISTED, disabledFacetAbstract.when());
+ assertEquals(Where.ANYWHERE, disabledFacetAbstract.where());
+ }
+
+
+ public void testDisabledWhereCollectionTableAnnotationPickedUpOn() {
+ class Customer {
+ @Disabled(where = Where.PARENTED_TABLES)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ final DisabledFacetAbstract disabledFacetAbstract = (DisabledFacetAbstract) facet;
+
+ assertEquals(When.ALWAYS, disabledFacetAbstract.when());
+ assertEquals(Where.PARENTED_TABLES, disabledFacetAbstract.where());
+ }
+
+
+ public void testDisabledWhenAndWhereAnnotationPickedUpOn() {
+ class Customer {
+ @Disabled(where = Where.PARENTED_TABLES, when=When.UNTIL_PERSISTED)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DisabledFacet.class);
+ final DisabledFacetAbstract disabledFacetAbstract = (DisabledFacetAbstract) facet;
+
+ assertEquals(When.UNTIL_PERSISTED, disabledFacetAbstract.when());
+ assertEquals(Where.PARENTED_TABLES, disabledFacetAbstract.where());
+ }
+
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/hidden/HiddenAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/hidden/HiddenAnnotationFacetFactoryTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/hidden/HiddenAnnotationFacetFactoryTest.java
new file mode 100644
index 0000000..ca3c50c
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/hidden/HiddenAnnotationFacetFactoryTest.java
@@ -0,0 +1,205 @@
+/*
+ * 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.progmodel.facets.hidden;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+
+import org.apache.isis.applib.annotation.Hidden;
+import org.apache.isis.applib.annotation.When;
+import org.apache.isis.applib.annotation.Where;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.hide.HiddenFacet;
+import org.apache.isis.core.progmodel.facets.AbstractFacetFactoryTest;
+import org.apache.isis.core.progmodel.facets.members.hidden.HiddenFacetAbstract;
+import org.apache.isis.core.progmodel.facets.members.hidden.annotation.HiddenAnnotationForMemberFacetFactory;
+
+public class HiddenAnnotationFacetFactoryTest extends AbstractFacetFactoryTest {
+
+ private HiddenAnnotationForMemberFacetFactory facetFactory;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ facetFactory = new HiddenAnnotationForMemberFacetFactory();
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ facetFactory = null;
+ super.tearDown();
+ }
+
+ public void testHiddenAnnotationPickedUpOnProperty() {
+ class Customer {
+ @Hidden
+ public int getNumberOfOrders() {
+ return 0;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "getNumberOfOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof HiddenFacetAbstract);
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testHiddenAnnotationPickedUpOnCollection() {
+ class Customer {
+ @Hidden
+ public Collection<?> getOrders() {
+ return null;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof HiddenFacetAbstract);
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testHiddenAnnotationPickedUpOnAction() {
+ class Customer {
+ @Hidden
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof HiddenFacetAbstract);
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testHiddenWhenAlwaysAnnotationPickedUpOn() {
+ class Customer {
+ @Hidden(when=When.ALWAYS)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ final HiddenFacetAbstract hiddenFacetAbstract = (HiddenFacetAbstract) facet;
+
+ assertEquals(When.ALWAYS, hiddenFacetAbstract.when());
+ }
+
+ public void testHiddenWhenNeverAnnotationPickedUpOn() {
+ class Customer {
+ @Hidden(when=When.NEVER)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ final HiddenFacetAbstract hiddenFacetAbstract = (HiddenFacetAbstract) facet;
+
+ assertEquals(When.NEVER, hiddenFacetAbstract.when());
+ }
+
+ public void testHiddenWhenOncePersistedAnnotationPickedUpOn() {
+ class Customer {
+ @Hidden(when=When.ONCE_PERSISTED)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ final HiddenFacetAbstract hiddenFacetAbstract = (HiddenFacetAbstract) facet;
+
+ assertEquals(When.ONCE_PERSISTED, hiddenFacetAbstract.when());
+ }
+
+ public void testHiddenWhenUntilPersistedAnnotationPickedUpOn() {
+ class Customer {
+ @Hidden(when=When.UNTIL_PERSISTED)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ final HiddenFacetAbstract hiddenFacetAbstract = (HiddenFacetAbstract) facet;
+
+ assertEquals(When.UNTIL_PERSISTED, hiddenFacetAbstract.when());
+ assertEquals(Where.ANYWHERE, hiddenFacetAbstract.where());
+ }
+
+ public void testHiddenWhereCollectionTableAnnotationPickedUpOn() {
+ class Customer {
+ @Hidden(where=Where.PARENTED_TABLES)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ final HiddenFacetAbstract hiddenFacetAbstract = (HiddenFacetAbstract) facet;
+
+ assertEquals(Where.PARENTED_TABLES, hiddenFacetAbstract.where());
+ assertEquals(When.ALWAYS, hiddenFacetAbstract.when());
+ }
+
+
+ public void testHiddenWhenAndWhereTableAnnotationPickedUpOn() {
+ class Customer {
+ @Hidden(where=Where.PARENTED_TABLES, when=When.UNTIL_PERSISTED)
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(HiddenFacet.class);
+ final HiddenFacetAbstract hiddenFacetAbstract = (HiddenFacetAbstract) facet;
+
+ assertEquals(Where.PARENTED_TABLES, hiddenFacetAbstract.where());
+ assertEquals(When.UNTIL_PERSISTED, hiddenFacetAbstract.when());
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/members/resolve/ResolveAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/members/resolve/ResolveAnnotationFacetFactoryTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/members/resolve/ResolveAnnotationFacetFactoryTest.java
new file mode 100644
index 0000000..ad7b1a5
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/members/resolve/ResolveAnnotationFacetFactoryTest.java
@@ -0,0 +1,155 @@
+/*
+ * 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.progmodel.facets.members.resolve;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.assertThat;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+
+import org.apache.isis.applib.annotation.Resolve;
+import org.apache.isis.applib.annotation.Disabled;
+import org.apache.isis.applib.annotation.Resolve.Type;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.FacetedMethod;
+import org.apache.isis.core.metamodel.facets.members.resolve.ResolveFacet;
+import org.apache.isis.core.progmodel.facets.AbstractFacetFactoryTest;
+
+public class ResolveAnnotationFacetFactoryTest extends AbstractFacetFactoryTest {
+
+ private ResolveAnnotationFacetFactory facetFactory;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ facetFactory = new ResolveAnnotationFacetFactory();
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ facetFactory = null;
+ super.tearDown();
+ }
+
+ public void testAnnotationWithNoHintPickedUpOnProperty() {
+
+ class Customer {
+ @Resolve
+ public int getNumberOfOrders() {
+ return 0;
+ }
+ }
+
+ facetedMethod = FacetedMethod.createForProperty(Customer.class, "numberOfOrders");
+ facetFactory.process(new ProcessMethodContext(Customer.class, facetedMethod.getMethod(), methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(ResolveFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof ResolveFacetAnnotation);
+ ResolveFacet resolveFacet = (ResolveFacet) facet;
+ assertThat(resolveFacet.value(), is(Resolve.Type.EAGERLY));
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testAnnotationWithEagerlyHintPickedUpOnProperty() {
+
+ class Customer {
+ @Resolve(Type.EAGERLY)
+ public int getNumberOfOrders() {
+ return 0;
+ }
+ }
+
+ facetedMethod = FacetedMethod.createForProperty(Customer.class, "numberOfOrders");
+ facetFactory.process(new ProcessMethodContext(Customer.class, facetedMethod.getMethod(), methodRemover, facetedMethod));
+
+ final ResolveFacet facet = facetedMethod.getFacet(ResolveFacet.class);
+ assertThat(facet.value(), is(Resolve.Type.EAGERLY));
+ }
+
+ public void testAnnotationForLazilyPickedUpOnProperty() {
+
+ class Customer {
+ @Resolve(Type.LAZILY)
+ public int getNumberOfOrders() {
+ return 0;
+ }
+ }
+
+ facetedMethod = FacetedMethod.createForProperty(Customer.class, "numberOfOrders");
+ facetFactory.process(new ProcessMethodContext(Customer.class, facetedMethod.getMethod(), methodRemover, facetedMethod));
+
+ final ResolveFacet facet = facetedMethod.getFacet(ResolveFacet.class);
+ assertThat(facet.value(), is(Resolve.Type.LAZILY));
+ }
+
+ public void testAnnotationNoHintPickedUpOnCollection() {
+ class Customer {
+ @Resolve
+ public Collection<?> getOrders() {
+ return null;
+ }
+ }
+ facetedMethod = FacetedMethod.createForCollection(Customer.class, "orders");
+ facetFactory.process(new ProcessMethodContext(Customer.class, facetedMethod.getMethod(), methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(ResolveFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof ResolveFacetAnnotation);
+ ResolveFacet resolveFacet = (ResolveFacet) facet;
+ assertThat(resolveFacet.value(), is(Resolve.Type.EAGERLY));
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testAnnotationEagerlyHintPickedUpOnCollection() {
+ class Customer {
+ @Resolve(Type.EAGERLY)
+ public Collection<?> getOrders() {
+ return null;
+ }
+ }
+ facetedMethod = FacetedMethod.createForCollection(Customer.class, "orders");
+ facetFactory.process(new ProcessMethodContext(Customer.class, facetedMethod.getMethod(), methodRemover, facetedMethod));
+
+ final ResolveFacet facet = facetedMethod.getFacet(ResolveFacet.class);
+ assertThat(facet.value(), is(Resolve.Type.EAGERLY));
+ }
+
+ public void testAnnotationWithLazilyHintPickedUpOnCollection() {
+ class Customer {
+ @Resolve(Type.LAZILY)
+ public Collection<?> getOrders() {
+ return null;
+ }
+ }
+ facetedMethod = FacetedMethod.createForCollection(Customer.class, "orders");
+ facetFactory.process(new ProcessMethodContext(Customer.class, facetedMethod.getMethod(), methodRemover, facetedMethod));
+
+ final ResolveFacet facet = facetedMethod.getFacet(ResolveFacet.class);
+ assertThat(facet.value(), is(Resolve.Type.LAZILY));
+ }
+
+
+}
http://git-wip-us.apache.org/repos/asf/isis/blob/e4735c72/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/naming/describedas/DescribedAsAnnotationFacetFactoryTest.java
----------------------------------------------------------------------
diff --git a/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/naming/describedas/DescribedAsAnnotationFacetFactoryTest.java b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/naming/describedas/DescribedAsAnnotationFacetFactoryTest.java
new file mode 100644
index 0000000..3c6832c
--- /dev/null
+++ b/framework/core/metamodel/src/test/java/org/apache/isis/core/progmodel/facets/naming/describedas/DescribedAsAnnotationFacetFactoryTest.java
@@ -0,0 +1,144 @@
+/*
+ * 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.progmodel.facets.naming.describedas;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+
+import org.apache.isis.applib.annotation.DescribedAs;
+import org.apache.isis.core.metamodel.facetapi.Facet;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessClassContext;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessMethodContext;
+import org.apache.isis.core.metamodel.facets.FacetFactory.ProcessParameterContext;
+import org.apache.isis.core.metamodel.facets.describedas.DescribedAsFacet;
+import org.apache.isis.core.metamodel.facets.describedas.DescribedAsFacetAbstract;
+import org.apache.isis.core.progmodel.facets.AbstractFacetFactoryTest;
+import org.apache.isis.core.progmodel.facets.members.describedas.annotation.DescribedAsAnnotationOnMemberFacetFactory;
+import org.apache.isis.core.progmodel.facets.object.describedas.annotation.DescribedAsAnnotationOnTypeFacetFactory;
+import org.apache.isis.core.progmodel.facets.param.describedas.annotation.DescribedAsAnnotationOnParameterFacetFactory;
+
+public class DescribedAsAnnotationFacetFactoryTest extends AbstractFacetFactoryTest {
+
+ public void testDescribedAsAnnotationPickedUpOnClass() {
+ final DescribedAsAnnotationOnTypeFacetFactory facetFactory = new DescribedAsAnnotationOnTypeFacetFactory();
+
+ @DescribedAs("some description")
+ class Customer {
+ }
+
+ facetFactory.process(new ProcessClassContext(Customer.class, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DescribedAsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DescribedAsFacetAbstract);
+ final DescribedAsFacetAbstract describedAsFacetAbstract = (DescribedAsFacetAbstract) facet;
+ assertEquals("some description", describedAsFacetAbstract.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testDescribedAsAnnotationPickedUpOnProperty() {
+ final DescribedAsAnnotationOnMemberFacetFactory facetFactory = new DescribedAsAnnotationOnMemberFacetFactory();
+
+ class Customer {
+ @SuppressWarnings("unused")
+ @DescribedAs("some description")
+ public int getNumberOfOrders() {
+ return 0;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "getNumberOfOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DescribedAsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DescribedAsFacetAbstract);
+ final DescribedAsFacetAbstract describedAsFacetAbstract = (DescribedAsFacetAbstract) facet;
+ assertEquals("some description", describedAsFacetAbstract.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testDescribedAsAnnotationPickedUpOnCollection() {
+ final DescribedAsAnnotationOnMemberFacetFactory facetFactory = new DescribedAsAnnotationOnMemberFacetFactory();
+
+ class Customer {
+ @SuppressWarnings("unused")
+ @DescribedAs("some description")
+ public Collection<?> getOrders() {
+ return null;
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "getOrders");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DescribedAsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DescribedAsFacetAbstract);
+ final DescribedAsFacetAbstract describedAsFacetAbstract = (DescribedAsFacetAbstract) facet;
+ assertEquals("some description", describedAsFacetAbstract.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testDescribedAsAnnotationPickedUpOnAction() {
+ final DescribedAsAnnotationOnMemberFacetFactory facetFactory = new DescribedAsAnnotationOnMemberFacetFactory();
+
+ class Customer {
+ @SuppressWarnings("unused")
+ @DescribedAs("some description")
+ public void someAction() {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction");
+
+ facetFactory.process(new ProcessMethodContext(Customer.class, actionMethod, methodRemover, facetedMethod));
+
+ final Facet facet = facetedMethod.getFacet(DescribedAsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DescribedAsFacetAbstract);
+ final DescribedAsFacetAbstract describedAsFacetAbstract = (DescribedAsFacetAbstract) facet;
+ assertEquals("some description", describedAsFacetAbstract.value());
+
+ assertNoMethodsRemoved();
+ }
+
+ public void testDescribedAsAnnotationPickedUpOnActionParameter() {
+ final DescribedAsAnnotationOnParameterFacetFactory facetFactory = new DescribedAsAnnotationOnParameterFacetFactory();
+
+ class Customer {
+ @SuppressWarnings("unused")
+ public void someAction(@DescribedAs("some description") final int x) {
+ }
+ }
+ final Method actionMethod = findMethod(Customer.class, "someAction", new Class[] { int.class });
+
+ facetFactory.processParams(new ProcessParameterContext(actionMethod, 0, facetedMethodParameter));
+
+ final Facet facet = facetedMethodParameter.getFacet(DescribedAsFacet.class);
+ assertNotNull(facet);
+ assertTrue(facet instanceof DescribedAsFacetAbstract);
+ final DescribedAsFacetAbstract describedAsFacetAbstract = (DescribedAsFacetAbstract) facet;
+ assertEquals("some description", describedAsFacetAbstract.value());
+ }
+
+}