| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.jackrabbit.test.api; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import javax.jcr.Node; |
| import javax.jcr.Property; |
| import javax.jcr.PropertyType; |
| import javax.jcr.RepositoryException; |
| import javax.jcr.Value; |
| import javax.jcr.nodetype.ConstraintViolationException; |
| import javax.jcr.nodetype.NodeType; |
| import javax.jcr.nodetype.NodeTypeIterator; |
| import javax.jcr.nodetype.NodeTypeManager; |
| import javax.jcr.nodetype.PropertyDefinition; |
| |
| import org.apache.jackrabbit.test.AbstractJCRTest; |
| import org.apache.jackrabbit.test.NotExecutableException; |
| import org.apache.jackrabbit.test.api.nodetype.NodeTypeUtil; |
| |
| /** |
| * <code>SetValueConstraintViolationExceptionTest</code> tests if setValue() |
| * throws a ConstraintViolationException either immediately (by setValue()) or |
| * on save, if the change would violate a value constraint. |
| * |
| */ |
| public class SetValueConstraintViolationExceptionTest extends AbstractJCRTest { |
| |
| /** |
| * Tests if setValue(InputStream value) and setValue(Value value) where |
| * value is a BinaryValue throw a ConstraintViolationException if the change |
| * would violate a value constraint |
| */ |
| public void testBinaryProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.BINARY, false, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No binary property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied1 = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| Value valueNotSatisfied2 = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied1 == null || valueNotSatisfied2 == null) { |
| throw new NotExecutableException("No binary property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), valueSatisfied); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(InputStream value) |
| InputStream in = valueNotSatisfied1.getStream(); |
| try { |
| prop.setValue(in); |
| node.save(); |
| fail("setValue(InputStream value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } finally { |
| try { in.close(); } catch (IOException ignore) {} |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| prop.setValue(valueNotSatisfied2); |
| node.save(); |
| fail("setValue(Value value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(boolean value) and setValue(Value value) where value is |
| * a BooleanValue throw a ConstraintViolationException if the change would |
| * violate a value constraint |
| */ |
| public void testBooleanProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.BOOLEAN, false, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No boolean property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No boolean property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), valueSatisfied); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(boolean value) |
| try { |
| prop.setValue(valueNotSatisfied.getBoolean()); |
| node.save(); |
| fail("setValue(boolean value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| prop.setValue(valueNotSatisfied); |
| node.save(); |
| fail("setValue(Value value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(Calendar value) and setValue(Value value) where value |
| * is a DateValue throw a ConstraintViolationException if the change would |
| * violate a value constraint |
| */ |
| public void testDateProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.DATE, false, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No date property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No date property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), valueSatisfied); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(Calendar value) |
| try { |
| prop.setValue(valueNotSatisfied.getDate()); |
| node.save(); |
| fail("setValue(Date value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| prop.setValue(valueNotSatisfied); |
| node.save(); |
| fail("setValue(Value value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(Double value) and setValue(Value value) where value is |
| * a DoubleValue throw a ConstraintViolationException if the change would |
| * violate a value constraint |
| */ |
| public void testDoubleProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.DOUBLE, false, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No double property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No double property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), valueSatisfied); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(double value) |
| try { |
| prop.setValue(valueNotSatisfied.getDouble()); |
| node.save(); |
| fail("setValue(double value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| prop.setValue(valueNotSatisfied); |
| node.save(); |
| fail("setValue(Value value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(Long value) and setValue(Value value) where value is a |
| * LongValue throw a ConstraintViolationException if the change would |
| * violate a value constraint |
| */ |
| public void testLongProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.LONG, false, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No long property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No long property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), valueSatisfied); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(long value) |
| try { |
| prop.setValue(valueNotSatisfied.getLong()); |
| node.save(); |
| fail("setValue(long value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| prop.setValue(valueNotSatisfied); |
| node.save(); |
| fail("setValue(Value value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| |
| /** |
| * Tests if setValue(Node value) and setValue(Value value) where value is a |
| * ReferenceValue throw a ConstraintViolationException if the change would |
| * violate a value constraint |
| */ |
| public void testReferenceProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.REFERENCE, false, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No reference property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| String valueConstraints[] = propDef.getValueConstraints(); |
| if (valueConstraints == null || valueConstraints.length == 0) { |
| throw new NotExecutableException("No reference property def with " |
| + "testable value constraints has been found"); |
| } |
| List<String> constraints = Arrays.asList(valueConstraints); |
| String nodeTypeSatisfied = constraints.get(0); |
| String nodeTypeNotSatisfied = null; |
| |
| NodeTypeManager manager = superuser.getWorkspace().getNodeTypeManager(); |
| NodeTypeIterator types = manager.getAllNodeTypes(); |
| |
| // find a NodeType which is not satisfying the constraints |
| while (types.hasNext()) { |
| NodeType type = types.nextNodeType(); |
| String name = type.getName(); |
| if (constraints.contains(name) || ntFrozenNode.equals(name)) { |
| continue; |
| } |
| if (type.getChildNodeDefinitions() != null |
| && type.getChildNodeDefinitions().length > 0) { |
| continue; |
| } |
| nodeTypeNotSatisfied = name; |
| break; |
| } |
| |
| if (nodeTypeNotSatisfied == null) { |
| throw new NotExecutableException("No reference property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| Node nodeSatisfied; |
| Node nodeNotSatisfied; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| |
| // create a referenceable node satisfying the constraint |
| nodeSatisfied = testRootNode.addNode(nodeName3, nodeTypeSatisfied); |
| ensureMixinType(nodeSatisfied, mixReferenceable); |
| |
| // create a referenceable node not satisfying the constraint |
| nodeNotSatisfied = testRootNode.addNode(nodeName4, nodeTypeNotSatisfied); |
| ensureMixinType(nodeNotSatisfied, mixReferenceable); |
| |
| // some implementations may require a save after addMixin() |
| testRootNode.getSession().save(); |
| |
| prop = node.setProperty(propDef.getName(), nodeSatisfied); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(Node value) |
| try { |
| prop.setValue(nodeNotSatisfied); |
| node.save(); |
| fail("setValue(Node value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| prop.setValue(superuser.getValueFactory().createValue(nodeNotSatisfied)); |
| node.save(); |
| fail("setValue(Value value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(Value[] values) where values are of type BinaryValue |
| * throw a ConstraintViolationException if the change would violate a value |
| * constraint |
| */ |
| public void testMultipleBinaryProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.BINARY, true, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No multiple binary property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No multiple binary property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), new Value[]{valueSatisfied}); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| try { |
| prop.setValue(new Value[]{valueNotSatisfied}); |
| node.save(); |
| fail("setValue(Value[] values) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(Value[] values) where values are of type BooleanValue |
| * throw a ConstraintViolationException if the change would violate a value |
| * constraint |
| */ |
| public void testMultipleBooleanProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.BOOLEAN, true, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No multiple boolean property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No multiple boolean property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), new Value[]{valueSatisfied}); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| try { |
| prop.setValue(new Value[]{valueNotSatisfied}); |
| node.save(); |
| fail("setValue(Value[] values) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| |
| /** |
| * Tests if setValue(Value[] values) where values are of type DateValue |
| * throw a ConstraintViolationException if the change would violate a value |
| * constraint |
| */ |
| public void testMultipleDateProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.DATE, true, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No multiple date property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No multiple date property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), new Value[]{valueSatisfied}); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| try { |
| prop.setValue(new Value[]{valueNotSatisfied}); |
| node.save(); |
| fail("setValue(Value[] values) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(Value[] values) where values are of type DoubleValue |
| * throw a ConstraintViolationException if the change would violate a value |
| * constraint |
| */ |
| public void testMultipleDoubleProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.DOUBLE, true, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No multiple double property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No multiple double property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), new Value[]{valueSatisfied}); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| prop.setValue(new Value[]{valueNotSatisfied}); |
| node.save(); |
| fail("setValue(Value[] values) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(Value[] values) where values are of type LongValue |
| * throw a ConstraintViolationException if the change would violate a value |
| * constraint |
| */ |
| public void testMultipleLongProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.LONG, true, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No multiple long property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does not satisfy the ValueConstraints of propDef |
| Value valueNotSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, false); |
| if (valueNotSatisfied == null) { |
| throw new NotExecutableException("No multiple long property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // find a Value that does satisfy the ValueConstraints of propDef |
| Value valueSatisfied = NodeTypeUtil.getValueAccordingToValueConstraints(superuser, propDef, true); |
| if (valueSatisfied == null) { |
| throw new NotExecutableException("The value constraints do not allow any value."); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| prop = node.setProperty(propDef.getName(), new Value[]{valueSatisfied}); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| prop.setValue(new Value[]{valueNotSatisfied}); |
| node.save(); |
| fail("setValue(Value value) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| /** |
| * Tests if setValue(Value[] values) where values are of type ReferenceValue |
| * throw a ConstraintViolationException if the change would violate a value |
| * constraint |
| */ |
| public void testMultipleReferenceProperty() |
| throws NotExecutableException, RepositoryException { |
| |
| // locate a PropertyDefinition with ValueConstraints |
| PropertyDefinition propDef = |
| NodeTypeUtil.locatePropertyDef(superuser, PropertyType.REFERENCE, true, false, true, false); |
| |
| if (propDef == null) { |
| throw new NotExecutableException("No multiple reference property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| String valueConstraints[] = propDef.getValueConstraints(); |
| if (valueConstraints == null || valueConstraints.length == 0) { |
| throw new NotExecutableException("No reference property def with " |
| + "testable value constraints has been found"); |
| } |
| List<String> constraints = Arrays.asList(valueConstraints); |
| String nodeTypeSatisfied = constraints.get(0); |
| String nodeTypeNotSatisfied = null; |
| |
| NodeTypeManager manager = superuser.getWorkspace().getNodeTypeManager(); |
| NodeTypeIterator types = manager.getAllNodeTypes(); |
| |
| // find a NodeType which is not satisfying the constraints |
| while (types.hasNext()) { |
| NodeType type = types.nextNodeType(); |
| String name = type.getName(); |
| if (constraints.contains(name) || ntFrozenNode.equals(name)) { |
| continue; |
| } |
| if (type.getChildNodeDefinitions() != null |
| && type.getChildNodeDefinitions().length > 0) { |
| continue; |
| } |
| nodeTypeNotSatisfied = name; |
| break; |
| } |
| |
| if (nodeTypeNotSatisfied == null) { |
| throw new NotExecutableException("No reference property def with " + |
| "testable value constraints has been found"); |
| } |
| |
| // create a sub node of testRootNode of type propDef.getDeclaringNodeType() |
| // and add a property with constraints to this node |
| Node node; |
| Property prop; |
| Node nodeSatisfied; |
| Node nodeNotSatisfied; |
| try { |
| String nodeType = propDef.getDeclaringNodeType().getName(); |
| node = testRootNode.addNode(nodeName2, nodeType); |
| |
| // create a referenceable node satisfying the constraint |
| nodeSatisfied = testRootNode.addNode(nodeName3, nodeTypeSatisfied); |
| ensureMixinType(nodeSatisfied, mixReferenceable); |
| |
| // create a referenceable node not satisfying the constraint |
| nodeNotSatisfied = testRootNode.addNode(nodeName4, nodeTypeNotSatisfied); |
| ensureMixinType(nodeNotSatisfied, mixReferenceable); |
| |
| // some implementations may require a save after addMixin() |
| testRootNode.getSession().save(); |
| |
| Value valueSatisfied = superuser.getValueFactory().createValue(nodeSatisfied); |
| prop = node.setProperty(propDef.getName(), new Value[]{valueSatisfied}); |
| testRootNode.getSession().save(); |
| } catch (ConstraintViolationException e) { |
| // implementation specific constraints do not allow to set up test environment |
| throw new NotExecutableException("Not able to create required test items."); |
| } |
| |
| // test of signature setValue(Value value) |
| try { |
| Value valueNotSatisfied = superuser.getValueFactory().createValue(nodeNotSatisfied); |
| prop.setValue(new Value[]{valueNotSatisfied}); |
| node.save(); |
| fail("setValue(Value[] values) must throw a ConstraintViolationException " + |
| "if the change would violate a node type constraint " + |
| "either immediately or on save"); |
| } catch (ConstraintViolationException e) { |
| // success |
| } |
| } |
| |
| } |