Author: rhauch Date: 2009-04-14 16:06:32 -0400 (Tue, 14 Apr 2009) New Revision: 823 Added: trunk/dna-jcr/src/test/java/org/jboss/dna/jcr/TypeRegistrationTest.java Modified: trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNodeDefinition.java trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNodeType.java trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrPropertyDefinition.java trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/RepositoryNodeTypeManager.java Log: DNA-339 JCR Type Registration and Unregistration Applying the "no key" patch, which removes the Key nested class from JcrNodeDefinition and JcrPropertyDefinition and instead uses the (existing) NodeDefinitionId and PropertyDefinitionId. The patch also adds test cases for type registration. Modified: trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNodeDefinition.java =================================================================== --- trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNodeDefinition.java 2009-04-14 16:41:54 UTC (rev 822) +++ trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNodeDefinition.java 2009-04-14 20:06:32 UTC (rev 823) @@ -27,15 +27,11 @@ import java.util.HashMap; import java.util.Map; import java.util.Set; -import javax.jcr.Node; -import javax.jcr.PathNotFoundException; -import javax.jcr.Value; import javax.jcr.nodetype.NodeDefinition; import javax.jcr.nodetype.NodeType; import net.jcip.annotations.Immutable; import org.jboss.dna.graph.ExecutionContext; import org.jboss.dna.graph.property.Name; -import org.jboss.dna.graph.property.NamespaceRegistry; /** * DNA implementation of the {@link NodeDefinition} class. @@ -212,6 +208,13 @@ defaultPrimaryTypeName, required); } + JcrNodeDefinition with( RepositoryNodeTypeManager nodeTypeManager ) { + JcrNodeType[] required = requiredPrimaryTypesByName.values().toArray(new JcrNodeType[requiredPrimaryTypesByName.size()]); + return new JcrNodeDefinition(this.context, nodeTypeManager, this.declaringNodeType, name, getOnParentVersion(), + isAutoCreated(), isMandatory(), isProtected(), allowsSameNameSiblings(), + defaultPrimaryTypeName, required); + } + /** * {@inheritDoc} * @@ -221,74 +224,4 @@ public String toString() { return getId().toString(); } - - Key getKey(boolean includeTypes) { - return new Key(this, includeTypes); - } - - /** - * Internal class that encapsulates composite unique identifier for child node definitions - */ - class Key { - String keyString; - - Key( Node node, - NamespaceRegistry registry ) throws Exception { - StringBuffer buff = new StringBuffer(); - - try { - String nodeName = node.getProperty(JcrLexicon.NAME.getString(registry)).getString(); - buff.append(nodeName); - } catch (PathNotFoundException pnfe) { - // Ignorable, means name is not set. - buff.append(JcrNodeType.RESIDUAL_ITEM_NAME); - } - - try { - Value[] requiredTypes = node.getProperty(JcrLexicon.REQUIRED_PRIMARY_TYPES.getString(registry)).getValues(); - - for (int i = 0; i < requiredTypes.length; i++) { - buff.append('_').append(requiredTypes[i].getString()); - } - } catch (PathNotFoundException pnfe) { - // No required types. Weird, but not debilitating. - } - - buff.append('_').append(node.getProperty(JcrLexicon.SAME_NAME_SIBLINGS.getString(registry)).getBoolean()); - - this.keyString = buff.toString(); - } - - Key( NodeDefinition def, - boolean includeTypes ) { - StringBuffer buff = new StringBuffer(); - buff.append(def.getName()); - - if (includeTypes) { - NodeType[] requiredTypes = def.getRequiredPrimaryTypes(); - for (int i = 0; i < requiredTypes.length; i++) { - buff.append('_').append(requiredTypes[i].getName()); - } - } - - buff.append('_').append(def.allowsSameNameSiblings()); - - this.keyString = buff.toString(); - } - - @Override - public boolean equals( Object ob ) { - if (!(ob instanceof Key)) { - return false; - } - - return keyString.equals(((Key)ob).keyString); - } - - @Override - public int hashCode() { - return keyString.hashCode(); - } - } - } Modified: trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNodeType.java =================================================================== --- trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNodeType.java 2009-04-14 16:41:54 UTC (rev 822) +++ trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNodeType.java 2009-04-14 20:06:32 UTC (rev 823) @@ -112,6 +112,8 @@ Collection<JcrPropertyDefinition> propertyDefinitions, boolean mixin, boolean orderableChildNodes ) { + assert context != null; + this.context = context; this.nodeTypeManager = nodeTypeManager; this.name = name; Modified: trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrPropertyDefinition.java =================================================================== --- trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrPropertyDefinition.java 2009-04-14 16:41:54 UTC (rev 822) +++ trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/JcrPropertyDefinition.java 2009-04-14 20:06:32 UTC (rev 823) @@ -26,7 +26,6 @@ import java.util.UUID; import java.util.regex.Pattern; import javax.jcr.Node; -import javax.jcr.PathNotFoundException; import javax.jcr.PropertyType; import javax.jcr.RepositoryException; import javax.jcr.Value; @@ -37,7 +36,6 @@ import org.jboss.dna.graph.property.DateTime; import org.jboss.dna.graph.property.Name; import org.jboss.dna.graph.property.NameFactory; -import org.jboss.dna.graph.property.NamespaceRegistry; import org.jboss.dna.graph.property.Path; import org.jboss.dna.graph.property.PathFactory; import org.jboss.dna.graph.property.ValueFactories; @@ -148,7 +146,7 @@ * @return a new <code>JcrPropertyDefinition</code> that is identical to the current object, but with the given * <code>context</code>. */ - JcrPropertyDefinition with( ExecutionContext context) { + JcrPropertyDefinition with( ExecutionContext context ) { return new JcrPropertyDefinition(context, this.declaringNodeType, this.name, this.getOnParentVersion(), this.isAutoCreated(), this.isMandatory(), this.isProtected(), this.getDefaultValues(), this.getRequiredType(), this.getValueConstraints(), this.isMultiple()); @@ -592,12 +590,7 @@ JcrValue jcrValue = (JcrValue)value; // Need to use the session execution context to handle the remaps - Name name = jcrValue.sessionCache() - .session() - .getExecutionContext() - .getValueFactories() - .getNameFactory() - .create(jcrValue.value()); + Name name = jcrValue.sessionCache().session().getExecutionContext().getValueFactories().getNameFactory().create(jcrValue.value()); for (int i = 0; i < constraints.length; i++) { if (constraints[i].equals(name)) { @@ -689,51 +682,4 @@ return false; } } - - Key getKey(boolean includeType) { - return new Key(this, includeType); - } - - /** - * Internal class that encapsulates composite unique identifier for property definitions - */ - class Key { - String keyString; - - Key( Node node, - NamespaceRegistry registry ) throws Exception { - String propertyName = JcrNodeType.RESIDUAL_ITEM_NAME; - - try { - propertyName = node.getProperty(JcrLexicon.NAME.getString(registry)).getString(); - } catch (PathNotFoundException pnfe) { - // Ignorable, means name is not set. - } - String requiredType = node.getProperty(JcrLexicon.REQUIRED_TYPE.getString(registry)).getString(); - boolean allowsMultiple = node.getProperty(JcrLexicon.MULTIPLE.getString(registry)).getBoolean(); - - this.keyString = propertyName + "-" + requiredType + "-" + allowsMultiple; - } - - Key( PropertyDefinition def, boolean includeType ) { - String requiredType = PropertyType.nameFromValue(def.getRequiredType()); - - this.keyString = def.getName() + (includeType ? "-" + requiredType : "") + "-" + def.isMultiple(); - } - - @Override - public boolean equals( Object ob ) { - if (!(ob instanceof Key)) { - return false; - } - - return keyString.equals(((Key)ob).keyString); - } - - @Override - public int hashCode() { - return keyString.hashCode(); - } - } - } Modified: trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/RepositoryNodeTypeManager.java =================================================================== --- trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/RepositoryNodeTypeManager.java 2009-04-14 16:41:54 UTC (rev 822) +++ trunk/dna-jcr/src/main/java/org/jboss/dna/jcr/RepositoryNodeTypeManager.java 2009-04-14 20:06:32 UTC (rev 823) @@ -92,7 +92,8 @@ */ private enum NodeCardinality { NO_SAME_NAME_SIBLINGS, - SAME_NAME_SIBLINGS + SAME_NAME_SIBLINGS, + ANY } RepositoryNodeTypeManager( ExecutionContext context, @@ -663,11 +664,14 @@ switch (typesToCheck) { case NO_SAME_NAME_SIBLINGS: - nodeDefs = typeName.allChildNodeDefinitions(childNodeName); + nodeDefs = typeName.allChildNodeDefinitions(childNodeName, false); break; case SAME_NAME_SIBLINGS: nodeDefs = typeName.allChildNodeDefinitions(childNodeName, true); break; + case ANY: + nodeDefs = typeName.allChildNodeDefinitions(childNodeName); + break; } assert nodeDefs != null; @@ -1045,12 +1049,13 @@ i++; } - nodeDefs.add(nodeDef.with(this.context)); + nodeDefs.add(nodeDef.with(this.context).with(this)); } JcrNodeType newNodeType = new JcrNodeType(this.context, this, name, supertypes, nodeType.getInternalPrimaryItemName(), nodeDefs, propertyDefs, nodeType.isMixin(), nodeType.hasOrderableChildNodes()); + typesPendingRegistration.add(newNodeType); } @@ -1158,11 +1163,14 @@ String nodeName ) throws RepositoryException { assert supertypes.size() > 0; // This is reasonable now that we default to having a supertype of nt:base - Map<JcrPropertyDefinition.Key, JcrPropertyDefinition> props = new HashMap<JcrPropertyDefinition.Key, JcrPropertyDefinition>(); + Map<PropertyDefinitionId, JcrPropertyDefinition> props = new HashMap<PropertyDefinitionId, JcrPropertyDefinition>(); for (JcrNodeType supertype : supertypes) { for (JcrPropertyDefinition property : supertype.propertyDefinitions()) { - JcrPropertyDefinition oldProp = props.put(property.getKey(false), property); + JcrPropertyDefinition oldProp = props.put(new PropertyDefinitionId(property.getInternalName(), + property.getInternalName(), + PropertyType.UNDEFINED, property.isMultiple()), + property); if (oldProp != null) { String oldPropTypeName = oldProp.getDeclaringNodeType().getName(); String propTypeName = property.getDeclaringNodeType().getName(); @@ -1176,11 +1184,13 @@ } } - Map<JcrNodeDefinition.Key, JcrNodeDefinition> childNodes = new HashMap<JcrNodeDefinition.Key, JcrNodeDefinition>(); + Map<NodeDefinitionId, JcrNodeDefinition> childNodes = new HashMap<NodeDefinitionId, JcrNodeDefinition>(); for (JcrNodeType supertype : supertypes) { for (JcrNodeDefinition childNode : supertype.childNodeDefinitions()) { - JcrNodeDefinition oldNode = childNodes.put(childNode.getKey(false), childNode); + JcrNodeDefinition oldNode = childNodes.put(new NodeDefinitionId(childNode.getInternalName(), + childNode.getInternalName(), new Name[0]), + childNode); if (oldNode != null) { String oldNodeTypeName = oldNode.getDeclaringNodeType().getName(); String childNodeTypeName = childNode.getDeclaringNodeType().getName(); @@ -1273,17 +1283,14 @@ if (node.isAutoCreated() && node.getDefaultPrimaryType() == null) { throw new RepositoryException(JcrI18n.autocreatedNodesNeedDefaults.text()); } - if (node.isMandatory() && node.getName() == null) { + if (node.isMandatory() && JcrNodeType.RESIDUAL_ITEM_NAME.equals(node.getName())) { throw new RepositoryException(JcrI18n.residualDefinitionsCannotBeMandatory.text("child nodes")); } Name nodeName = context.getValueFactories().getNameFactory().create(node.getName()); nodeName = nodeName == null ? JcrNodeType.RESIDUAL_NAME : nodeName; - List<JcrNodeDefinition> ancestors = findChildNodeDefinitions(supertypes, - nodeName, - node.allowsSameNameSiblings() ? NodeCardinality.SAME_NAME_SIBLINGS : NodeCardinality.NO_SAME_NAME_SIBLINGS, - pendingTypes); + List<JcrNodeDefinition> ancestors = findChildNodeDefinitions(supertypes, nodeName, NodeCardinality.ANY, pendingTypes); for (JcrNodeDefinition ancestor : ancestors) { if (ancestor.isProtected()) { @@ -1353,7 +1360,7 @@ assert supertypes != null; assert pendingTypes != null; - if (prop.isMandatory() && !prop.isProtected() && prop.getName() == null) { + if (prop.isMandatory() && !prop.isProtected() && JcrNodeType.RESIDUAL_ITEM_NAME.equals(prop.getName())) { throw new RepositoryException(JcrI18n.residualDefinitionsCannotBeMandatory.text("properties")); } Added: trunk/dna-jcr/src/test/java/org/jboss/dna/jcr/TypeRegistrationTest.java =================================================================== --- trunk/dna-jcr/src/test/java/org/jboss/dna/jcr/TypeRegistrationTest.java (rev 0) +++ trunk/dna-jcr/src/test/java/org/jboss/dna/jcr/TypeRegistrationTest.java 2009-04-14 20:06:32 UTC (rev 823) @@ -0,0 +1,1317 @@ +/* + * JBoss DNA (http://www.jboss.org/dna) + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. Some portions may be licensed + * to Red Hat, Inc. under one or more contributor license agreements. + * See the AUTHORS.txt file in the distribution for a full listing of + * individual contributors. + * + * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA + * is licensed to you under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * JBoss DNA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.dna.jcr; + +import static org.hamcrest.core.Is.is; +import static org.hamcrest.core.IsNull.notNullValue; +import static org.junit.Assert.assertThat; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import javax.jcr.PropertyType; +import javax.jcr.RepositoryException; +import javax.jcr.nodetype.NodeDefinition; +import javax.jcr.nodetype.PropertyDefinition; +import org.jboss.dna.graph.ExecutionContext; +import org.jboss.dna.graph.property.Name; +import org.jboss.dna.graph.property.NameFactory; +import org.junit.Before; +import org.junit.Test; +import org.mockito.MockitoAnnotations; + +public class TypeRegistrationTest { + + private static final String TEST_TYPE_NAME = "dna:testNode"; + private static final String TEST_TYPE_NAME2 = "dna:testNode2"; + private static final String TEST_PROPERTY_NAME = "dna:testProperty"; + private static final String TEST_CHILD_NODE_NAME = "dna:testChildNode"; + + private ExecutionContext context; + private RepositoryNodeTypeManager repoTypeManager; + private JcrNodeType ntTemplate; + private NameFactory nameFactory; + private JcrNodeType base; + private JcrNodeType referenceable; + private JcrNodeType unstructured; + private JcrNodeType root; + private JcrNodeType versionHistory; + private JcrNodeType hierarchyNode; + private JcrNodeType file; + + @Before + public void beforeEach() throws Exception { + MockitoAnnotations.initMocks(this); + context = new ExecutionContext(); + nameFactory = context.getValueFactories().getNameFactory(); + + JcrNodeTypeSource source = null; + source = new JcrBuiltinNodeTypeSource(context, source); + source = new DnaBuiltinNodeTypeSource(this.context, source); + repoTypeManager = new RepositoryNodeTypeManager(context, source); + + base = repoTypeManager.getNodeType(JcrNtLexicon.BASE); + referenceable = repoTypeManager.getNodeType(JcrMixLexicon.REFERENCEABLE); + unstructured = repoTypeManager.getNodeType(JcrNtLexicon.UNSTRUCTURED); + root = repoTypeManager.getNodeType(DnaLexicon.ROOT); + versionHistory = repoTypeManager.getNodeType(JcrNtLexicon.VERSION_HISTORY); + hierarchyNode = repoTypeManager.getNodeType(JcrNtLexicon.HIERARCHY_NODE); + file = repoTypeManager.getNodeType(JcrNtLexicon.FILE); + } + + private Name nameFor( String name ) { + return context.getValueFactories().getNameFactory().create(name); + } + + private JcrNodeTypeSource sourceFor( final JcrNodeType nodeType ) { + return new AbstractJcrNodeTypeSource() { + @Override + public List<JcrNodeType> getDeclaredNodeTypes() { + return Collections.singletonList(nodeType); + } + }; + } + + private JcrNodeTypeSource sourceFor( final JcrNodeType... nodeTypes ) { + return new AbstractJcrNodeTypeSource() { + @Override + public List<JcrNodeType> getDeclaredNodeTypes() { + return Arrays.asList(nodeTypes); + } + }; + } + + @Test( expected = AssertionError.class ) + public void shouldNotAllowNullDefinition() throws Exception { + repoTypeManager.registerNodeTypes(null); + } + + @Test( expected = AssertionError.class ) + public void shouldNotAllowTemplateWithNullContext() throws Exception { + repoTypeManager.registerNodeTypes(sourceFor(new JcrNodeType(null, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), Arrays.asList(new JcrNodeType[] {}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, + AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowNodeTypeWithNoName() throws Exception { + ntTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, null, + Arrays.asList(new JcrNodeType[] {}), AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, AbstractJcrNodeTypeSource.NO_PROPERTIES, + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + repoTypeManager.registerNodeTypes(sourceFor(ntTemplate)); + } + + @Test + public void shouldAllowNewDefinitionWithNoChildNodesOrProperties() throws Exception { + Name testTypeName = nameFactory.create(TEST_TYPE_NAME); + ntTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, testTypeName, + Arrays.asList(new JcrNodeType[] {}), AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, AbstractJcrNodeTypeSource.NO_PROPERTIES, + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> testNodeTypes = repoTypeManager.registerNodeTypes(sourceFor(ntTemplate)); + JcrNodeType testNodeType = testNodeTypes.get(0); + + assertThat(testNodeType.getName(), is(TEST_TYPE_NAME)); + JcrNodeType nodeTypeFromRepo = repoTypeManager.getNodeType(testTypeName); + assertThat(nodeTypeFromRepo, is(notNullValue())); + assertThat(nodeTypeFromRepo.getName(), is(TEST_TYPE_NAME)); + } + + // @Test( expected = RepositoryException.class ) + // public void shouldNotAllowModificationIfAllowUpdatesIsFalse() throws Exception { + // ntTemplate.setName("nt:base"); + // repoTypeManager.registerNodeType(ntTemplate, false); + // } + + // @Test( expected = RepositoryException.class ) + // public void shouldNotAllowRedefinitionOfNewTypeIfAllowUpdatesIsFalse() throws Exception { + // Name testTypeName = nameFactory.create(TEST_TYPE_NAME); + // ntTemplate.setName(TEST_TYPE_NAME); + // ntTemplate.setDeclaredSupertypeNames(new String[] {"nt:base"}); + // + // JcrNodeType testNodeType = repoTypeManager.registerNodeType(ntTemplate, false); + // + // assertThat(testNodeType.getName(), is(TEST_TYPE_NAME)); + // JcrNodeType nodeTypeFromRepo = repoTypeManager.getNodeType(testTypeName); + // assertThat(nodeTypeFromRepo, is(notNullValue())); + // assertThat(nodeTypeFromRepo.getName(), is(TEST_TYPE_NAME)); + // + // testNodeType = repoTypeManager.registerNodeType(ntTemplate, false); + // } + + @Test + public void shouldAllowDefinitionWithExistingSupertypes() throws Exception { + Name testTypeName = nameFactory.create(TEST_TYPE_NAME); + + ntTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, testTypeName, + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> testNodeTypes = repoTypeManager.registerNodeTypes(sourceFor(ntTemplate)); + JcrNodeType testNodeType = testNodeTypes.get(0); + + assertThat(testNodeType.getName(), is(TEST_TYPE_NAME)); + JcrNodeType nodeTypeFromRepo = repoTypeManager.getNodeType(testTypeName); + assertThat(nodeTypeFromRepo, is(notNullValue())); + assertThat(nodeTypeFromRepo.getName(), is(TEST_TYPE_NAME)); + + } + + @Test + public void shouldAllowDefinitionWithSupertypesFromTypesRegisteredInSameCall() throws Exception { + ntTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType ntTemplate2 = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME2), Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, ntTemplate2}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, ntTemplate2))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowDefinitionWithSupertypesFromTypesRegisteredInSameCallInWrongOrder() throws Exception { + // Try to register the supertype AFTER the class that registers it + ntTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType ntTemplate2 = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME2), Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate2, ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate2, ntTemplate))); + } + + @Test + public void shouldAllowDefinitionWithAProperty() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + null, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.LONG, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false)}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + } + + @Test + public void shouldAllowDefinitionWithProperties() throws Exception { + + ntTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] { + new JcrPropertyDefinition(context, null, null, + OnParentVersionBehavior.VERSION.getJcrValue(), false, false, + false, AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.LONG, AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false), + new JcrPropertyDefinition(context, null, null, + OnParentVersionBehavior.VERSION.getJcrValue(), false, false, + false, AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.STRING, AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + true), + new JcrPropertyDefinition(context, null, nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), false, false, + false, AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.STRING, AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false)}), AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowAutocreatedPropertyWithNoDefault() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + true, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.LONG, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowAutocreatedResidualProperty() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + null, + OnParentVersionBehavior.VERSION.getJcrValue(), + true, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.UNDEFINED, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + + } + + // @Test + // public void shouldAllowAutocreatedNamedPropertyWithDefault() throws Exception { + // ntTemplate.setName(TEST_TYPE_NAME); + // ntTemplate.setDeclaredSupertypeNames(new String[] {"nt:base", "mix:referenceable"}); + // + // JcrPropertyDefinitionTemplate prop = new JcrPropertyDefinitionTemplate(this.context); + // prop.setName(TEST_PROPERTY_NAME); + // prop.setRequiredType(PropertyType.UNDEFINED); + // prop.setAutoCreated(true); + // prop.setDefaultValues(new String[] {"<default>"}); + // ntTemplate.getPropertyDefinitionTemplates().add(prop); + // + // List<NodeTypeDefinition> templates = Arrays.asList(new NodeTypeDefinition[] {ntTemplate}); + // compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(templates, false)); + // } + // + // @Test( expected = RepositoryException.class ) + // public void shouldNotAllowSingleValuedPropertyWithMultipleDefaults() throws Exception { + // ntTemplate.setName(TEST_TYPE_NAME); + // ntTemplate.setDeclaredSupertypeNames(new String[] {"nt:base", "mix:referenceable"}); + // + // JcrPropertyDefinitionTemplate prop = new JcrPropertyDefinitionTemplate(this.context); + // prop.setName(TEST_PROPERTY_NAME); + // prop.setRequiredType(PropertyType.UNDEFINED); + // prop.setAutoCreated(true); + // prop.setDefaultValues(new String[] {"<default>", "too many values"}); + // ntTemplate.getPropertyDefinitionTemplates().add(prop); + // + // List<NodeTypeDefinition> templates = Arrays.asList(new NodeTypeDefinition[] {ntTemplate}); + // compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(templates, false)); + // } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowMandatoryResidualProperty() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + null, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + true, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.UNDEFINED, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + + } + + @Test + public void shouldAllowTypeWithChildNode() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, false, false, true, + JcrNtLexicon.BASE, + new JcrNodeType[] {base})}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + + } + + @Test + public void shouldAllowTypeWithMultipleChildNodes() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] { + new JcrNodeDefinition(context, null, nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), false, false, + false, true, JcrNtLexicon.BASE, new JcrNodeType[] {base}), + new JcrNodeDefinition(context, null, nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), false, false, + false, false, JcrNtLexicon.BASE, new JcrNodeType[] {unstructured}), + new JcrNodeDefinition(context, null, nameFor(TEST_CHILD_NODE_NAME + "2"), + OnParentVersionBehavior.VERSION.getJcrValue(), false, false, + false, true, JcrNtLexicon.BASE, new JcrNodeType[] {base}), + + }), AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowAutocreatedChildNodeWithNoDefaultPrimaryType() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + true, false, false, false, + null, new JcrNodeType[] {base}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowMandatoryResidualChildNode() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + null, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, true, false, false, + JcrNtLexicon.BASE, + new JcrNodeType[] {base}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowOverridingProtectedProperty() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + JcrLexicon.PRIMARY_TYPE, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.NAME, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowOverridingProtectedChildNode() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {root, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + JcrLexicon.SYSTEM, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, false, false, false, + JcrNtLexicon.BASE, + new JcrNodeType[] {base}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowOverridingMandatoryChildNodeWithOptionalChildNode() throws Exception { + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {versionHistory}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + JcrLexicon.ROOT_VERSION, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, false, false, false, + JcrNtLexicon.BASE, + new JcrNodeType[] {base}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate))); + + } + + @Test + public void shouldAllowOverridingPropertyFromCommonAncestor() throws Exception { + /* + * testNode declares prop testProperty + * testNodeB extends testNode + * testNodeC extends testNode + * testNodeD extends testNodeB and testNodeC and overrides testProperty --> LEGAL + */ + + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.UNDEFINED, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeCTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "C"), Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeDTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "D"), + Arrays.asList(new JcrNodeType[] {nodeBTemplate, nodeCTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.STRING, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate, nodeCTemplate, nodeDTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, + nodeBTemplate, + nodeCTemplate, + nodeDTemplate))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowOverridingPropertyFromDifferentAncestors() throws Exception { + /* + * testNode + * testNodeB extends testNode and declares prop testProperty + * testNodeC extends testNode and declares prop testProperty + * testNodeD extends testNodeB and testNodeC and overrides testProperty --> ILLEGAL + */ + + ntTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.UNDEFINED, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeCTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "C"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.UNDEFINED, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeDTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "D"), + Arrays.asList(new JcrNodeType[] {nodeBTemplate, nodeCTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.STRING, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate, nodeCTemplate, nodeDTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, + nodeBTemplate, + nodeCTemplate, + nodeDTemplate))); + } + + @Test + public void shouldAllowOverridingChildNodeFromCommonAncestor() throws Exception { + /* + * testNode declares node testChildNode + * testNodeB extends testNode + * testNodeC extends testNode + * testNodeD extends testNodeB and testNodeC and overrides testChildNode --> LEGAL + */ + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + null, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, false, false, false, + JcrNtLexicon.BASE, + new JcrNodeType[] {base}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeCTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "C"), Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeDTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "D"), + Arrays.asList(new JcrNodeType[] {nodeBTemplate, nodeCTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + JcrLexicon.SYSTEM, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + false, + JcrNtLexicon.UNSTRUCTURED, + new JcrNodeType[] {unstructured}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate, nodeCTemplate, nodeDTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, + nodeBTemplate, + nodeCTemplate, + nodeDTemplate))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowOverridingChildNodeFromDifferentAncestors() throws Exception { + /* + * testNode + * testNodeB extends testNode and declares node testChildNode + * testNodeC extends testNode and declares node testChildNode + * testNodeD extends testNodeB and testNodeC and overrides testChildNode --> ILLEGAL + */ + ntTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + null, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + false, + JcrNtLexicon.BASE, + new JcrNodeType[] {base}),}), + + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeCTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "C"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + null, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + false, + JcrNtLexicon.BASE, + new JcrNodeType[] {base}),}), + + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeDTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "D"), + Arrays.asList(new JcrNodeType[] {nodeBTemplate, nodeCTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + JcrLexicon.SYSTEM, + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + false, + JcrNtLexicon.UNSTRUCTURED, + new JcrNodeType[] {unstructured}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate, nodeCTemplate, nodeDTemplate}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, + nodeBTemplate, + nodeCTemplate, + nodeDTemplate))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowExtendingChildNodeIfSnsChanges() throws Exception { + /* + * testNode declares node testChildNode with no SNS + * testNodeB extends testNode with node testChildNode with SNS -> ILLEGAL + */ + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, false, false, false, + null, new JcrNodeType[] {root}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + true, + JcrNtLexicon.UNSTRUCTURED, + new JcrNodeType[] {unstructured}),}), + + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate,}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, nodeBTemplate))); + + } + + @Test + public void shouldAllowExtendingPropertyIfMultipleChanges() throws Exception { + /* + * testNode declares SV property testProperty + * testNodeB extends testNode with MV property testProperty with incompatible type -> LEGAL + * testNodeC extends testNode, testNodeB -> LEGAL + */ + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.LONG, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.DATE, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + true),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeCTemplate = new JcrNodeType(context, AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "C"), Arrays.asList(new JcrNodeType[] {ntTemplate, + nodeBTemplate}), AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate, nodeCTemplate,}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, + nodeBTemplate, + nodeCTemplate))); + } + + @Test + public void shouldAllowOverridingPropertyIfTypeNarrows() throws Exception { + /* + * testNode declares SV property testProperty of type UNDEFINED + * testNodeB extends testNode with SV property testProperty of type STRING -> LEGAL + */ + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.STRING, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.LONG, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate,}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, nodeBTemplate))); + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowOverridingPropertyIfTypeDoesNotNarrow() throws Exception { + /* + * testNode declares SV property testProperty of type DATE + * testNodeB extends testNode with SV property testProperty of type NAME -> ILLEGAL + */ + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.DATE, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + AbstractJcrNodeTypeSource.NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( + context, + null, + nameFor(TEST_PROPERTY_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + AbstractJcrNodeTypeSource.NO_DEFAULT_VALUES, + PropertyType.NAME, + AbstractJcrNodeTypeSource.NO_CONSTRAINTS, + false),}), + AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate,}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, nodeBTemplate))); + } + + @Test + public void shouldAllowOverridingChildNodeIfRequiredTypesNarrow() throws Exception { + /* + * testNode declares No-SNS childNode testChildNode requiring type nt:hierarchy + * testNodeB extends testNode with No-SNS childNode testChildNode requiring type nt:file -> LEGAL + */ + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + false, + null, + new JcrNodeType[] {hierarchyNode}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + true, + null, + new JcrNodeType[] {file}),}), + + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate,}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, nodeBTemplate))); + + } + + @Test( expected = RepositoryException.class ) + public void shouldNotAllowOverridingChildNodeIfRequiredTypesDoNotNarrow() throws Exception { + /* + * testNode declares No-SNS childNode testChildNode requiring type nt:hierarchy + * testNodeB extends testNode with No-SNS childNode testChildNode requiring type nt:base -> ILLEGAL + */ + ntTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME), + Arrays.asList(new JcrNodeType[] {base, referenceable}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + false, + null, + new JcrNodeType[] {hierarchyNode}),}), + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + JcrNodeType nodeBTemplate = new JcrNodeType( + context, + AbstractJcrNodeTypeSource.NO_NODE_TYPE_MANAGER, + nameFor(TEST_TYPE_NAME + "B"), + Arrays.asList(new JcrNodeType[] {ntTemplate}), + AbstractJcrNodeTypeSource.NO_PRIMARY_ITEM_NAME, + Arrays.asList(new JcrNodeDefinition[] {new JcrNodeDefinition( + context, + null, + nameFor(TEST_CHILD_NODE_NAME), + OnParentVersionBehavior.VERSION.getJcrValue(), + false, + false, + false, + true, + null, + new JcrNodeType[] {base}),}), + + AbstractJcrNodeTypeSource.NO_PROPERTIES, AbstractJcrNodeTypeSource.NOT_MIXIN, + AbstractJcrNodeTypeSource.UNORDERABLE_CHILD_NODES); + + List<JcrNodeType> templates = Arrays.asList(new JcrNodeType[] {ntTemplate, nodeBTemplate,}); + compareTemplatesToNodeTypes(templates, repoTypeManager.registerNodeTypes(sourceFor(ntTemplate, nodeBTemplate))); + + } + + private void compareTemplatesToNodeTypes( List<JcrNodeType> templates, + List<JcrNodeType> nodeTypes ) { + assertThat(templates.size(), is(nodeTypes.size())); + + for (int i = 0; i < nodeTypes.size(); i++) { + JcrNodeType jntt = templates.get(i); + compareTemplateToNodeType(jntt, null); + compareTemplateToNodeType(jntt, nodeTypes.get(i)); + } + } + + private void compareTemplateToNodeType( JcrNodeType template, + JcrNodeType nodeType ) { + Name nodeTypeName = nameFactory.create(template.getName()); + if (nodeType == null) { + nodeType = repoTypeManager.getNodeType(nodeTypeName); + assertThat(nodeType.nodeTypeManager(), is(notNullValue())); + } + + assertThat(nodeType, is(notNullValue())); + assertThat(nodeType.getName(), is(template.getName())); + + assertThat(nodeType.getDeclaredSupertypes().length, is(template.getDeclaredSupertypes().length)); + for (int i = 0; i < template.getDeclaredSupertypes().length; i++) { + assertThat(template.getDeclaredSupertypes()[i].getName(), is(nodeType.getDeclaredSupertypes()[i].getName())); + } + assertThat(template.isMixin(), is(nodeType.isMixin())); + assertThat(template.hasOrderableChildNodes(), is(nodeType.hasOrderableChildNodes())); + + PropertyDefinition[] propertyDefs = nodeType.getDeclaredPropertyDefinitions(); + List<JcrPropertyDefinition> propertyTemplates = Arrays.asList(template.getDeclaredPropertyDefinitions()); + + assertThat(propertyDefs.length, is(propertyTemplates.size())); + for (JcrPropertyDefinition pt : propertyTemplates) { + JcrPropertyDefinition propertyTemplate = pt; + + PropertyDefinition matchingDefinition = null; + for (int i = 0; i < propertyDefs.length; i++) { + PropertyDefinition pd = propertyDefs[i]; + + String ptName = propertyTemplate.getName() == null ? JcrNodeType.RESIDUAL_ITEM_NAME : propertyTemplate.getName(); + if (pd.getName().equals(ptName) && pd.getRequiredType() == propertyTemplate.getRequiredType() + && pd.isMultiple() == propertyTemplate.isMultiple()) { + matchingDefinition = pd; + break; + } + } + + comparePropertyTemplateToPropertyDefinition(propertyTemplate, (JcrPropertyDefinition)matchingDefinition); + } + + NodeDefinition[] childNodeDefs = nodeType.getDeclaredChildNodeDefinitions(); + List<JcrNodeDefinition> childNodeTemplates = Arrays.asList(template.getDeclaredChildNodeDefinitions()); + + assertThat(childNodeDefs.length, is(childNodeTemplates.size())); + for (JcrNodeDefinition nt : childNodeTemplates) { + JcrNodeDefinition childNodeTemplate = nt; + + NodeDefinition matchingDefinition = null; + for (int i = 0; i < childNodeDefs.length; i++) { + JcrNodeDefinition nd = (JcrNodeDefinition)childNodeDefs[i]; + + String ntName = childNodeTemplate.getName() == null ? JcrNodeType.RESIDUAL_ITEM_NAME : childNodeTemplate.getName(); + if (nd.getName().equals(ntName) && nd.allowsSameNameSiblings() == childNodeTemplate.allowsSameNameSiblings()) { + + boolean matchesOnRequiredTypes = childNodeTemplate.getRequiredPrimaryTypeNames() + .equals(nd.getRequiredPrimaryTypeNames()); + + if (matchesOnRequiredTypes) { + matchingDefinition = nd; + break; + } + } + } + + compareNodeTemplateToNodeDefinition(childNodeTemplate, (JcrNodeDefinition)matchingDefinition); + } + + } + + private void comparePropertyTemplateToPropertyDefinition( JcrPropertyDefinition template, + JcrPropertyDefinition definition ) { + + assertThat(definition, is(notNullValue())); + assertThat(definition.getDeclaringNodeType(), is(notNullValue())); + // Had to match on name to even get to the definition + // assertThat(template.getName(), is(definition.getName())); + + assertThat(template.getValueConstraints(), is(definition.getValueConstraints())); + assertThat(template.getOnParentVersion(), is(definition.getOnParentVersion())); + assertThat(template.getRequiredType(), is(definition.getRequiredType())); + assertThat(template.isAutoCreated(), is(definition.isAutoCreated())); + assertThat(template.isMandatory(), is(definition.isMandatory())); + assertThat(template.isMultiple(), is(definition.isMultiple())); + assertThat(template.isProtected(), is(definition.isProtected())); + } + + private void compareNodeTemplateToNodeDefinition( JcrNodeDefinition template, + JcrNodeDefinition definition ) { + assertThat(definition, is(notNullValue())); + assertThat(definition.getDeclaringNodeType(), is(notNullValue())); + // Had to match on name to even get to the definition + // assertThat(template.getName(), is(definition.getName())); + + assertThat(template.getOnParentVersion(), is(definition.getOnParentVersion())); + assertThat(template.isAutoCreated(), is(definition.isAutoCreated())); + assertThat(template.isMandatory(), is(definition.isMandatory())); + assertThat(template.isProtected(), is(definition.isProtected())); + + assertThat(template.with(repoTypeManager).getDefaultPrimaryType(), is(definition.getDefaultPrimaryType())); + assertThat(template.allowsSameNameSiblings(), is(definition.allowsSameNameSiblings())); + + // assertThat(template.getRequiredPrimaryTypeNames(), is(definition.getRequiredPrimaryTypeNames())); + + } +} Property changes on: trunk/dna-jcr/src/test/java/org/jboss/dna/jcr/TypeRegistrationTest.java ___________________________________________________________________ Name: svn:mime-type + text/plain