| /* |
| * 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. |
| */ |
| |
| describe('The Node Type Manager', function() { |
| |
| // The documentation about the spec format can be found here: |
| // http://pivotal.github.com/jasmine/ |
| var defaultNTJsonURL = "src/defaultNT/defaultNT.json"; |
| |
| function compareItemDefitions(actualItemDefinitions, expectedItemDefinitions){ |
| expect(actualItemDefinitions.autoCreated).toEqual(expectedItemDefinitions.autoCreated); |
| expect(actualItemDefinitions.mandatory).toEqual(expectedItemDefinitions.mandatory); |
| expect(actualItemDefinitions.protected).toEqual(expectedItemDefinitions.protected); |
| expect(actualItemDefinitions.onParentVersion).toEqual(expectedItemDefinitions.onParentVersion); |
| } |
| |
| function compareNodeTypeProperties(actualNodeType, expectedNodeType){ |
| expect(actualNodeType.mixin).toBe(expectedNodeType.mixin); |
| expect(actualNodeType.orderableChildNodes).toBe(expectedNodeType.orderableChildNodes); |
| expect(actualNodeType.declaredSupertypes).toEqual(expectedNodeType.declaredSupertypes); |
| } |
| |
| function comparePropertyDefProperties(actualPropertyDefs, expectedPropertyDefs){ |
| expect(actualPropertyDefs.defaultValues).toEqual(expectedPropertyDefs.defaultValues); |
| expect(actualPropertyDefs.valueConstraints).toEqual(expectedPropertyDefs.valueConstraints); |
| expect(actualPropertyDefs.requiredType).toEqual(expectedPropertyDefs.requiredType); |
| expect(actualPropertyDefs.multiple).toEqual(expectedPropertyDefs.multiple); |
| } |
| |
| function compareChildNodeDefProperties(actualChildNodeDefs, expectedChildNodeDefs){ |
| expect(actualChildNodeDefs.allowsSameNameSiblings).toEqual(expectedChildNodeDefs.allowsSameNameSiblings); |
| expect(actualChildNodeDefs.defaultPrimaryType).toEqual(expectedChildNodeDefs.defaultPrimaryType); |
| expect(actualChildNodeDefs.requiredPrimaryTypes).toEqual(expectedChildNodeDefs.requiredPrimaryTypes); |
| } |
| |
| it('returns the node type names.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt:base" : { |
| }, |
| "n1" : { |
| },"n2" : { |
| },"n3" : { |
| },"n4" : { |
| }} |
| }; |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| expect(ntManager.getNodeTypeNames()).toEqual(["nt:base","n1","n2","n3","n4"]); |
| }); |
| |
| it('returns the specified node type.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt:base" : { |
| }, |
| "aNodeType" : { |
| }} |
| }; |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| expect(ntManager.getNodeType("aNodeType")).toEqual(settings.nodeTypesJson["aNodeType"]); |
| }); |
| |
| describe('collects', function () { |
| var ntManager; |
| |
| describe('all child node definitions from the super types ', function () { |
| |
| function arrayContainsCnDefWithName(array, cnDefName){ |
| var found = false; |
| for (var i=0; i<array.length && found===false; i++){ |
| found = array[i].name === cnDefName; |
| } |
| return found; |
| } |
| |
| it('with <getAllChildNodeDefinitions()>.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : {"aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType", "aMixinParentNodeType" ], |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef1" |
| },{ |
| "name" : "childNodeDef2"} |
| ] |
| },"aParentNodeType" : { |
| "declaredSupertypes" : [ "aGrandParentNodeType" ], |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef3" |
| },{ |
| "name" : "childNodeDef4"} |
| ] |
| },"aMixinParentNodeType" : { |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef5" |
| },{ |
| "name" : "childNodeDef6"} |
| ] |
| },"aGrandParentNodeType" : { |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef7" |
| },{ |
| "name" : "childNodeDef8"} |
| ] |
| },"nt:base" : { |
| "declaredSupertypes" : [] |
| }} |
| }; |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var resultingChildNodeDefs = ntManager.getNodeType("aNodeType").getAllChildNodeDefinitions(); |
| expect(resultingChildNodeDefs.length).toBe(8); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef1")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef2")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef3")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef4")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef5")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef6")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef7")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef8")).toBe(true); |
| }); |
| |
| it('with <getAllChildNodeDefinitions()> but does not contain duplicate entries from the parents.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : {"aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType" ], |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef1" |
| },{ |
| "name" : "childNodeDef2"} |
| ] |
| },"aParentNodeType" : { |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef1" |
| },{ |
| "name" : "childNodeDef2"} |
| ] |
| },"nt:base" : { |
| } |
| } |
| }; |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var resultingChildNodeDefs = ntManager.getNodeType("aNodeType").getAllChildNodeDefinitions(); |
| expect(resultingChildNodeDefs.length).toBe(2); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef1")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef2")).toBe(true); |
| }); |
| |
| it('with <getAllChildNodeDefinitions()> and lists child node definitions with the same name but different content.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : {"aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType" ], |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef1", |
| "requiredPrimaryTypes": [ |
| "aNodeType" |
| ], |
| },{ |
| "name" : "childNodeDef2" |
| } |
| ] |
| },"aParentNodeType" : { |
| "declaredSupertypes" : [ "aGrandParentNodeType" ], |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef1" |
| },{ |
| "name" : "childNodeDef2" |
| } |
| ] |
| },"aGrandParentNodeType" : { |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef1" |
| } |
| ] |
| },"nt:base" : { |
| "declaredSupertypes" : [] |
| }} |
| }; |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var resultingChildNodeDefs = ntManager.getNodeType("aNodeType").getAllChildNodeDefinitions(); |
| |
| expect(resultingChildNodeDefs.length).toBe(3); |
| |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef1")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef2")).toBe(true); |
| }); |
| |
| it('with <getAllChildNodeDefinitions()> but does not follow circular dependencies.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : {"aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType", "aMixinParentNodeType" ], |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef1" |
| },{ |
| "name" : "childNodeDef2"} |
| ] |
| },"aParentNodeType" : { |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef3" |
| },{ |
| "name" : "childNodeDef4"} |
| ] |
| },"aMixinParentNodeType" : { |
| //this creates a circular dependency |
| "declaredSupertypes" : [ "aNodeType" ], |
| "declaredChildNodeDefinitions" : [{ |
| "name" : "childNodeDef5" |
| },{ |
| "name" : "childNodeDef6"} |
| ] |
| },"nt:base" : { |
| "declaredSupertypes" : [] |
| }} |
| }; |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| |
| var resultingChildNodeDefs = ntManager.getNodeType("aNodeType").getAllChildNodeDefinitions(); |
| expect(resultingChildNodeDefs.length).toBe(6); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef1")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef2")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef3")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef4")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef5")).toBe(true); |
| expect(arrayContainsCnDefWithName(resultingChildNodeDefs, "childNodeDef6")).toBe(true); |
| }); |
| }); |
| |
| describe('all property definitions from the super types', function () { |
| |
| function arrayContainsPropDefWithName(array, propDefName){ |
| var found = false; |
| for (var i=0; i<array.length && found===false; i++){ |
| found = array[i].name === propDefName; |
| } |
| return found; |
| } |
| |
| it('with <getAllPropertyDefinitions()>', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : {"aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType", "aMixinParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1" |
| },{ |
| "name" : "propertyDef2"} |
| ] |
| },"aParentNodeType" : { |
| "declaredSupertypes" : [ "aGrandParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef3" |
| },{ |
| "name" : "propertyDef4"} |
| ] |
| },"aMixinParentNodeType" : { |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef5" |
| },{ |
| "name" : "propertyDef6"} |
| ] |
| },"aGrandParentNodeType" : { |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef7" |
| },{ |
| "name" : "propertyDef8"} |
| ] |
| },"nt:base" : { |
| "declaredSupertypes" : [] |
| }} |
| }; |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var resultingPropertyDefs = ntManager.getNodeType("aNodeType").getAllPropertyDefinitions(); |
| expect(resultingPropertyDefs.length).toBe(8); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef1")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef2")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef3")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef4")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef5")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef6")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef7")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef8")).toBe(true); |
| }); |
| |
| it('with <getAllPropertyDefinitions()> but does not contain duplicate entries from the parents.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : {"aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1" |
| },{ |
| "name" : "propertyDef2"} |
| ] |
| },"aParentNodeType" : { |
| "declaredSupertypes" : [ "aGrandParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1" |
| },{ |
| "name" : "propertyDef2"} |
| ] |
| },"aGrandParentNodeType" : { |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1" |
| },{ |
| "name" : "propertyDef2"} |
| ] |
| },"nt:base" : { |
| "declaredSupertypes" : [] |
| }} |
| }; |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var resultingPropertyDefs = ntManager.getNodeType("aNodeType").getAllPropertyDefinitions(); |
| expect(resultingPropertyDefs.length).toBe(2); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef1")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef2")).toBe(true); |
| }); |
| |
| it('with <getAllPropertyDefinitions()> and lists property definitions with the same name but different content.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : {"aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1", |
| "multiple": true |
| },{ |
| "name" : "propertyDef2", |
| "multiple": true |
| } |
| ] |
| },"aParentNodeType" : { |
| "declaredSupertypes" : [ "aGrandParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1" |
| },{ |
| "name" : "propertyDef2", |
| "multiple": true |
| } |
| ] |
| },"aGrandParentNodeType" : { |
| "declaredSupertypes" : [ "aGrandGrandParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1", |
| "valueConstraints": [ |
| "nt:versionHistory" |
| ], |
| },{ |
| "name" : "propertyDef2", |
| "multiple": true |
| } |
| ] |
| },"aGrandGrandParentNodeType" : { |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1", |
| "defaultValues": [{ |
| "name": "nt:base", |
| "type": "Name" |
| }], |
| },{ |
| "name" : "propertyDef2", |
| "multiple": true |
| } |
| ] |
| },"nt:base" : { |
| "declaredSupertypes" : [] |
| }} |
| }; |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var resultingPropertyDefs = ntManager.getNodeType("aNodeType").getAllPropertyDefinitions(); |
| expect(resultingPropertyDefs.length).toBe(5); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef1")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef2")).toBe(true); |
| }); |
| |
| it('with <getAllPropertyDefinitions()> but does not follow circular dependencies.', function() { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : {"aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType", "aMixinParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1" |
| },{ |
| "name" : "propertyDef2"} |
| ] |
| },"aParentNodeType" : { |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef3" |
| },{ |
| "name" : "propertyDef4"} |
| ] |
| },"aMixinParentNodeType" : { |
| // this supertype should not create a circular dependency |
| "declaredSupertypes" : [ "aNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef5" |
| },{ |
| "name" : "propertyDef6"} |
| ] |
| },"nt:base" : { |
| "declaredSupertypes" : [] |
| }} |
| }; |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var resultingPropertyDefs = ntManager.getNodeType("aNodeType").getAllPropertyDefinitions(); |
| expect(resultingPropertyDefs.length).toBe(6); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef1")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef2")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef3")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef4")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef5")).toBe(true); |
| expect(arrayContainsPropDefWithName(resultingPropertyDefs, "propertyDef6")).toBe(true); |
| }); |
| |
| }); |
| }); |
| |
| describe('recognizes the default settings', function () { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt": { |
| "declaredPropertyDefinitions": [{"name": "propertyDef1"}, {"name": "propertyDef2"}], |
| "declaredChildNodeDefinitions": [{"name": "childNodeDef1"}, {"name": "childNodeDef2"}], |
| }, |
| "nt:base" : { |
| } |
| } |
| }; |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| |
| it('for the properties at the node type level', function() { |
| compareNodeTypeProperties(ntManager.getNodeType("nt"), ntManager.internalGetDefaultNodeType()) |
| }); |
| |
| describe('for the properties at the property definition level', function() { |
| it('that do inherit from item definition', function() { |
| comparePropertyDefProperties(ntManager.getNodeType("nt").getAllPropertyDefinitions(), ntManager.internalGetDefaultNodeType().declaredPropertyDefinitions); |
| }); |
| it('that don\'t inherit from item definition', function() { |
| compareItemDefitions(ntManager.getNodeType("nt").getAllPropertyDefinitions(), ntManager.internalGetDefaultNodeType().declaredPropertyDefinitions); |
| }); |
| }); |
| |
| describe('for the properties at the child node definition level', function() { |
| ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| it('that do inherit from item definition', function() { |
| compareChildNodeDefProperties(ntManager.getNodeType("nt").getAllChildNodeDefinitions(), ntManager.internalGetDefaultNodeType().declaredChildNodeDefinitions); |
| }); |
| |
| it('that don\'t inherit from item definition', function() { |
| compareItemDefitions(ntManager.getNodeType("nt").getAllChildNodeDefinitions(), ntManager.internalGetDefaultNodeType().declaredChildNodeDefinitions); |
| }); |
| }); |
| }); |
| |
| describe('overwrites the default settings', function () { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt": { |
| "mixin": true, |
| "orderableChildNodes": true, |
| "declaredSupertypes": [ |
| "otherNodeType" |
| ], |
| "declaredPropertyDefinitions": [ |
| { |
| "defaultValues": [{ |
| "string": "a default value", |
| "type": "String" |
| }], |
| "valueConstraints": ["banana","apple"], |
| "requiredType": "String", |
| "multiple": true, |
| |
| "autoCreated": true, |
| "mandatory": true, |
| "protected": true, |
| "onParentVersion": "VERSION" |
| } |
| ], |
| "declaredChildNodeDefinitions": [ |
| { |
| "allowsSameNameSiblings": true, |
| "defaultPrimaryType": "otherNodeType", |
| "requiredPrimaryTypes": [ |
| "otherNodeType" |
| ], |
| |
| "autoCreated": true, |
| "mandatory": true, |
| "protected": true, |
| "onParentVersion": "VERSION" |
| } |
| ] |
| }, |
| "nt:base" : { |
| }, |
| "otherNodeType" : { |
| |
| } |
| } |
| }; |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| |
| it('for the properties at the node type level', function() { |
| compareNodeTypeProperties(ntManager.getNodeType("nt"), settings.nodeTypesJson.nt) |
| }); |
| |
| describe('for the properties at the property definition level', function() { |
| it('that do inherit from item definition', function() { |
| comparePropertyDefProperties(ntManager.getNodeType("nt").getAllPropertyDefinitions(), settings.nodeTypesJson.nt.declaredPropertyDefinitions); |
| }); |
| it('that don\'t inherit from item definition', function() { |
| compareItemDefitions(ntManager.getNodeType("nt").getAllPropertyDefinitions(), settings.nodeTypesJson.nt.declaredPropertyDefinitions); |
| }); |
| }); |
| |
| describe('for the properties at the child node definition level', function() { |
| it('that do inherit from item definition', function() { |
| compareChildNodeDefProperties(ntManager.getNodeType("nt").getAllChildNodeDefinitions(), settings.nodeTypesJson.nt.declaredChildNodeDefinitions); |
| }); |
| |
| it('that don\'t inherit from item definition', function() { |
| compareItemDefitions(ntManager.getNodeType("nt").getAllChildNodeDefinitions(), settings.nodeTypesJson.nt.declaredChildNodeDefinitions); |
| }); |
| }); |
| }); |
| |
| describe('returns in getApplicableCnTypesPerCnDef()', function () { |
| /* adding a keySize function to Object */ |
| if (typeof Object.keySize === "undefined") { |
| Object.keySize = function(obj) { |
| var keySize = 0, key; |
| for (key in obj) { |
| if (obj.hasOwnProperty(key)) keySize++; |
| } |
| return keySize; |
| }; |
| } |
| describe('all valid child node types', function () { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt:base" : { |
| }, |
| "aSuperType" : { |
| "declaredChildNodeDefinitions": [ |
| { |
| "requiredPrimaryTypes": [ |
| "supCnDef1" |
| ], |
| "name" : "supCnDef1Name" |
| }, |
| { |
| "requiredPrimaryTypes": [ |
| "supCnDef3", |
| "supCnDef2" |
| ], |
| "name" : "*" |
| } |
| ] |
| }, |
| "mix:supSupCnDef1" : { |
| "mixin": true |
| }, |
| "mix:supSupCnDef2" : { |
| "mixin": true |
| }, |
| "supCnDef1" : { |
| "declaredSupertypes": [ |
| "mix:supSupCnDef1", |
| "mix:supSupCnDef2" |
| ] |
| }, |
| "supCnDef1Sub1" : { |
| "declaredSupertypes": [ |
| "supCnDef1" |
| ] |
| }, |
| "supCnDef1Sub11" : { |
| "declaredSupertypes": [ |
| "supCnDef1Sub1" |
| ] |
| }, |
| "supCnDef2": { |
| }, |
| "supCnDef2Sub1" : { |
| "declaredSupertypes": [ |
| "supCnDef2" |
| ] |
| }, |
| "supCnDef2Sub11" : { |
| "declaredSupertypes": [ |
| "supCnDef2Sub1" |
| ] |
| }, |
| "supCnDef2Mixin" : { |
| "declaredSupertypes": [ |
| "supCnDef2Sub11" |
| ], |
| "mixin": true |
| }, |
| "supCnDef3": { |
| }, |
| "supCnDef3Def2" : { |
| "declaredSupertypes": [ |
| "supCnDef3", |
| "supCnDef2" |
| ] |
| }, |
| "aNodeType" : { |
| "declaredSupertypes": [ |
| "aSuperType" |
| ], |
| "declaredChildNodeDefinitions": [ |
| { |
| "requiredPrimaryTypes": [ |
| "cnDef1" |
| ], |
| "name" : "cnDef1Name" |
| }, |
| { |
| "requiredPrimaryTypes": [ |
| "cnDef2" |
| ], |
| "name" : "cnDef2Name" |
| }, |
| { |
| "requiredPrimaryTypes": [ |
| "cnDef3" |
| ], |
| "name" : "*" |
| |
| }, |
| { |
| "requiredPrimaryTypes": [ |
| "cnDef4", |
| "cnDef5" |
| ], |
| "name" : "*" |
| } |
| ] |
| }, |
| "cnDef1" : { |
| }, |
| "cnDef2" : { |
| }, |
| "cnDef2Sub1" : { |
| "declaredSupertypes": [ |
| "cnDef2" |
| ] |
| }, |
| "cnDef2Sub11" : { |
| "declaredSupertypes": [ |
| "cnDef2Sub1" |
| ] |
| }, |
| "cnDef2Sub2" : { |
| "declaredSupertypes": [ |
| "cnDef2" |
| ] |
| }, |
| "cnDef3" : { |
| }, |
| "cnDef4" : { |
| }, |
| "cnDef5" : { |
| "declaredSupertypes": [ |
| "cnDef2Sub2" |
| ] |
| }, |
| "cnDef4Sub1" : { |
| "declaredSupertypes": [ |
| "cnDef4" |
| ] |
| }, |
| "cnDef4Sub11" : { |
| "declaredSupertypes": [ |
| "cnDef4Sub1" |
| ] |
| }, |
| "cnDef4Sub2" : { |
| "declaredSupertypes": [ |
| "cnDef4" |
| ] |
| }, |
| "cnDef5Sub1" : { |
| "declaredSupertypes": [ |
| "cnDef5" |
| ] |
| }, |
| "cnDef5Sub2" : { |
| "declaredSupertypes": [ |
| "cnDef5", |
| "cnDef2Sub2" |
| ] |
| }, |
| "CnDef2Mixin" : { |
| "declaredSupertypes": [ |
| "cnDef5Sub2" |
| ], |
| "mixin": true |
| }, |
| "cnDef45" : { |
| "declaredSupertypes": [ |
| "cnDef4Sub11", |
| "cnDef5Sub2" |
| ] |
| }, |
| "cnDef45Sub1" : { |
| "declaredSupertypes": [ |
| "cnDef45" |
| ] |
| } |
| } |
| }; |
| |
| // see "/src/test/resources/applicableChildNodeTypesDatastructure.jpg" for a |
| // visualization of the test datastructure |
| |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var applicableCnTypes = ntManager.getNodeType("aNodeType").getApplicableCnTypesPerCnDef(); |
| |
| it('generally', function() { |
| expect(applicableCnTypes!=null).toBe(true); |
| expect(applicableCnTypes).toBeDefined(); |
| |
| expect(applicableCnTypes["cnDef1Name"]).toBeDefined(); |
| expect(Object.keySize(applicableCnTypes["cnDef1Name"])).toBe(1); |
| expect(applicableCnTypes["cnDef1Name"]["cnDef1"]).toBeDefined(); |
| |
| expect(applicableCnTypes["cnDef2Name"]).toBeDefined(); |
| expect(Object.keySize(applicableCnTypes["cnDef2Name"])).toBe(10); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef2"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef2Sub1"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef2Sub11"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef2Sub2"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef5"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef5Sub1"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef5Sub2"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef45"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["cnDef45Sub1"]).toBeDefined(); |
| expect(applicableCnTypes["cnDef2Name"]["CnDef2Mixin"]).toBeDefined(); |
| |
| expect(applicableCnTypes["*"]).toBeDefined(); |
| expect(Object.keySize(applicableCnTypes["*"])).toBe(4); |
| expect(applicableCnTypes["*"]["supCnDef3Def2"]).toBeDefined(); |
| |
| expect(applicableCnTypes["*"]["cnDef3"]).toBeDefined(); |
| |
| expect(applicableCnTypes["*"]["cnDef45"]).toBeDefined(); |
| expect(applicableCnTypes["*"]["cnDef45Sub1"]).toBeDefined(); |
| |
| expect(applicableCnTypes["supCnDef1Name"]).toBeDefined(); |
| expect(Object.keySize(applicableCnTypes["supCnDef1Name"])).toBe(3); |
| expect(applicableCnTypes["supCnDef1Name"]["supCnDef1"]).toBeDefined(); |
| expect(applicableCnTypes["supCnDef1Name"]["supCnDef1Sub1"]).toBeDefined(); |
| expect(applicableCnTypes["supCnDef1Name"]["supCnDef1Sub11"]).toBeDefined(); |
| }); |
| |
| it('with multiple requiredPrimaryTypes', function() { |
| expect(applicableCnTypes["*"]).toBeDefined(); |
| expect(applicableCnTypes["*"]["supCnDef3Def2"]).toBeDefined(); |
| expect(applicableCnTypes["*"]["cnDef3"]).toBeDefined(); |
| expect(applicableCnTypes["*"]["cnDef45"]).toBeDefined(); |
| expect(applicableCnTypes["*"]["cnDef45Sub1"]).toBeDefined(); |
| }); |
| |
| it('including all valid super types\' child node types and its subtypes with multiple requiredPrimaryTypes', function() { |
| expect(applicableCnTypes["supCnDef1Name"]).toBeDefined(); |
| expect(applicableCnTypes["supCnDef1Name"]["supCnDef1Sub1"]).toBeDefined(); |
| expect(applicableCnTypes["supCnDef1Name"]["supCnDef1Sub1"]).toBeDefined(); |
| expect(applicableCnTypes["supCnDef1Name"]["supCnDef1Sub11"]).toBeDefined(); |
| |
| expect(applicableCnTypes["*"]["supCnDef3Def2"]).toBeDefined(); |
| }); |
| |
| }); |
| describe('all node types', function () { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt:base" : { |
| }, |
| "aNodeType" : { |
| "declaredChildNodeDefinitions": [ |
| { |
| // no required primary types declared: |
| "name" : "cnDef1Name" |
| } |
| ] |
| }, |
| "nt1" : { |
| }, |
| "nt2" : { |
| } |
| } |
| }; |
| |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var applicableCnTypes = ntManager.getNodeType("aNodeType").getApplicableCnTypesPerCnDef(); |
| |
| it('if required primary types is \'nt:base\'', function() { |
| expect(applicableCnTypes!=null).toBe(true); |
| expect(applicableCnTypes["cnDef1Name"]).toBeDefined(true); |
| expect(applicableCnTypes["cnDef1Name"]["nt:base"]).toBeDefined(true); |
| expect(applicableCnTypes["cnDef1Name"]["aNodeType"]).toBeDefined(true); |
| expect(applicableCnTypes["cnDef1Name"]["nt1"]).toBeDefined(true); |
| expect(applicableCnTypes["cnDef1Name"]["nt2"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypes["cnDef1Name"])).toBe(4); |
| }); |
| }); |
| it('the residual definition', function () { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt:base" : { |
| }, |
| "aNodeType" : { |
| "declaredChildNodeDefinitions": [{ |
| "requiredPrimaryTypes": [ |
| "cnType1" |
| ], |
| "name" : "cnDef1Name" |
| },{ |
| "requiredPrimaryTypes": [ |
| "cnType2" |
| ], |
| "name" : "*" |
| } |
| ] |
| }, |
| "cnType1" : { |
| }, |
| "cnType2" : { |
| } |
| } |
| }; |
| |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var applicableCnTypes = ntManager.getNodeType("aNodeType").getApplicableCnTypesPerCnDef(); |
| |
| expect(applicableCnTypes!=null).toBe(true); |
| expect(applicableCnTypes["cnDef1Name"]).toBeDefined(true); |
| expect(applicableCnTypes["cnDef1Name"]["cnType1"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypes["cnDef1Name"])).toBe(1); |
| |
| expect(applicableCnTypes["*"]["cnType2"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypes["*"])).toBe(1); |
| }); |
| |
| it('the applicable mixin node types if \'true\' has been passed to the mixin parameter', function () { |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt:base" : { |
| }, |
| "aNodeType" : { |
| "declaredChildNodeDefinitions": [{ |
| "requiredPrimaryTypes": [ |
| "cnType1" |
| ], |
| "name" : "cnDef1Name" |
| },{ |
| "requiredPrimaryTypes": [ |
| "cnType2" |
| ], |
| "name" : "cnDef2Name" |
| },{ |
| "requiredPrimaryTypes": [ |
| "cnType3" |
| ], |
| "name" : "*" |
| } |
| ] |
| }, |
| "cnType1" : { |
| }, |
| "cnType2" : { |
| "mixin": true |
| }, |
| "cnType3" : { |
| "mixin": true |
| } |
| } |
| }; |
| |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var applicableCnTypesWithMixin = ntManager.getNodeType("aNodeType").getApplicableCnTypesPerCnDef(true); |
| |
| expect(applicableCnTypesWithMixin!=null).toBe(true); |
| expect(applicableCnTypesWithMixin["cnDef1Name"]).toBeDefined(true); |
| expect(applicableCnTypesWithMixin["cnDef1Name"]["cnType1"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypesWithMixin["cnDef1Name"])).toBe(1); |
| |
| expect(applicableCnTypesWithMixin["cnDef2Name"]).toBeDefined(true); |
| expect(applicableCnTypesWithMixin["cnDef2Name"]["cnType2"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypesWithMixin["cnDef1Name"])).toBe(1); |
| |
| expect(applicableCnTypesWithMixin["*"]["cnType3"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypesWithMixin["*"])).toBe(1); |
| |
| |
| var applicableCnTypesWithoutMixin = ntManager.getNodeType("aNodeType").getApplicableCnTypesPerCnDef(false); |
| |
| expect(applicableCnTypesWithoutMixin!=null).toBe(true); |
| expect(applicableCnTypesWithoutMixin["cnDef1Name"]).toBeDefined(true); |
| expect(applicableCnTypesWithoutMixin["cnDef1Name"]["cnType1"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypesWithoutMixin["cnDef1Name"])).toBe(1); |
| |
| expect(applicableCnTypesWithoutMixin["cnDef2Name"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypesWithoutMixin["cnDef2Name"])).toBe(0); |
| |
| expect(applicableCnTypesWithoutMixin["*"]).toBeDefined(true); |
| expect(Object.keySize(applicableCnTypesWithoutMixin["*"])).toBe(0); |
| }); |
| }); |
| |
| describe('checks in canAddChildNode()', function () { |
| |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "ntResidualChild": { |
| "declaredChildNodeDefinitions": [ |
| { |
| "requiredPrimaryTypes": [ |
| "nt:base" |
| ], |
| "name" : "*" |
| } |
| ] |
| }, |
| "ntNonResidualChild": { |
| "declaredChildNodeDefinitions": [ |
| { |
| "requiredPrimaryTypes": [ |
| "nt:base" |
| ], |
| "name" : "aChildNodeDef1" |
| } |
| ] |
| }, |
| "ntNonResidualProtectedChild": { |
| "declaredChildNodeDefinitions": [ |
| { |
| "requiredPrimaryTypes": [ |
| "nt:base" |
| ], |
| "name" : "aChildNodeDef2", |
| "protected": true |
| } |
| ] |
| }, |
| "ntWithOtherChildNode": { |
| "declaredChildNodeDefinitions": [ |
| { |
| "requiredPrimaryTypes": [ |
| "otherNodeType" |
| ], |
| "name" : "*" |
| } |
| ] |
| }, |
| "nt:base" : { |
| }, |
| "otherNodeType" : { |
| }, |
| "inheritedNodeType" : { |
| "declaredSupertypes": [ |
| "otherNodeType" |
| ] |
| }, |
| "aNodeType" : { |
| "declaredChildNodeDefinitions": [ |
| { |
| "requiredPrimaryTypes": [ |
| "aChildNodeType" |
| ], |
| "name" : "*" |
| } |
| ] |
| }, |
| "aChildNodeType" : { |
| }, |
| "aChildNodesSubtype" : { |
| "declaredSupertypes": [ |
| "aChildNodeType" |
| ] |
| } |
| } |
| }; |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| var ntBase = ntManager.getNodeType("nt:base"); |
| var ntResidualChild = ntManager.getNodeType("ntResidualChild"); |
| |
| describe('if the name is valid', function() { |
| it('for residual node names', function() { |
| expect(ntManager.getNodeType("ntResidualChild").canAddChildNode("childNodeDefName", ntBase)).toBe(true); |
| }); |
| it('for non residual node names', function() { |
| expect(ntManager.getNodeType("ntNonResidualChild").canAddChildNode("aChildNodeDef1", ntBase)).toBe(true); |
| expect(ntManager.getNodeType("ntNonResidualChild").canAddChildNode("aChildNodeDefA", ntBase)).toBe(false); |
| }); |
| }); |
| it('if the destination is not protected', function() { |
| expect(ntManager.getNodeType("ntNonResidualProtectedChild").canAddChildNode("aChildNodeDef2", ntResidualChild)).toBe(false); |
| }); |
| describe('if the type is valid', function() { |
| it('for direct types', function() { |
| var otherNodeType = ntManager.getNodeType("otherNodeType"); |
| expect(ntManager.getNodeType("ntWithOtherChildNode").canAddChildNode("otherNodeType", otherNodeType)).toBe(true); |
| expect(ntManager.getNodeType("ntWithOtherChildNode").canAddChildNode("otherNodeType", ntBase)).toBe(false); |
| }); |
| it('for an inherited type', function() { |
| var inheritedNodeType = ntManager.getNodeType("inheritedNodeType"); |
| expect(ntManager.getNodeType("ntWithOtherChildNode").canAddChildNode("inheritedNodeType", inheritedNodeType)).toBe(true); |
| expect(ntManager.getNodeType("ntWithOtherChildNode").canAddChildNode("inheritedNodeType", ntBase)).toBe(false); |
| }); |
| it('for subtype', function() { |
| var aChildNodeType = ntManager.getNodeType("aChildNodeType"); |
| var aChildNodesSubtype = ntManager.getNodeType("aChildNodesSubtype"); |
| expect(ntManager.getNodeType("aNodeType").canAddChildNode("aNodeName", aChildNodeType)).toBe(true); |
| expect(ntManager.getNodeType("aNodeType").canAddChildNode("aNodeName", aChildNodesSubtype)).toBe(true); |
| }); |
| }); |
| }); |
| |
| describe('checks in canAddProperty()', function () { |
| |
| var settings = { |
| "defaultNTJsonURL": defaultNTJsonURL, |
| "nodeTypesJson" : { |
| "nt:base" : { |
| }, |
| "aParentNodeType" : { |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef6", |
| "requiredType": "Date" |
| },{ |
| "name" : "propertyDef4", |
| "requiredType": "Date", |
| "protected": true |
| },{ |
| "name" : "propertyDef5", |
| "requiredType": "String" |
| },{ |
| "name" : "*", |
| "requiredType": "String" |
| },{ |
| "name" : "propertyDef2", |
| "requiredType": "undefined" |
| }] |
| }, |
| "aNodeType" : { |
| "declaredSupertypes" : [ "aParentNodeType" ], |
| "declaredPropertyDefinitions" : [{ |
| "name" : "propertyDef1", |
| "requiredType": "String" |
| }] |
| } |
| } |
| }; |
| |
| var ntManager = new org.apache.sling.jcr.js.nodetypes.NodeTypeManager(settings); |
| |
| describe('if the name and type is applicable', function() { |
| it('for residual property names', function() { |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("aPropertyDef", "String")).toBe(true); |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("aPropertyDef", "Binary")).toBe(false); |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("aPropertyDef", "Date")).toBe(false); |
| }); |
| it('for undefined property types', function() { |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef2", "Binary")).toBe(true); |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef2", "Date")).toBe(true); |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef2", "String")).toBe(true); |
| }); |
| it('for non residual property names', function() { |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef1", "String")).toBe(true); |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef1", "Binary")).toBe(false); |
| }); |
| it('for properties of super types', function() { |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef5", "String")).toBe(true); |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef5", "Binary")).toBe(false); |
| }); |
| }); |
| it('if the type is case insensitive', function() { |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef1", "stRING")).toBe(true); |
| }); |
| it('if the name and type is not applicable for protected properties', function() { |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef4", "Date")).toBe(false); |
| }); |
| it('that residual property definitions are not applicable for non residual property types', function() { |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef6", "Date")).toBe(true); |
| expect(ntManager.getNodeType("aNodeType").canAddProperty("propertyDef6", "String")).toBe(false); |
| }); |
| }); |
| |
| function sameArrayContent(array1, array2){ |
| expect(array1.length).toBe(array2.length); |
| for (var i=0; i<array2.length; i++){ |
| if (typeof array2[i] !== "undefined") { |
| expect(array1).toContain(array2[i]); |
| } |
| } |
| } |
| |
| }); |
