/** * @inheritDoc */ public int getType() throws RepositoryException { return property.getType(); }
/** {@inheritDoc} */ public int getType() throws RepositoryException, RemoteException { try { return property.getType(); } catch (RepositoryException ex) { throw getRepositoryException(ex); } }
@Override public boolean evaluateTyped(Property property) { try { return !excludedNames.contains(property.getName()) && !excludedTypes.contains(PropertyType.nameFromValue(property.getType())); } catch (RepositoryException e) { return false; } }
@Override public int getType() { if (isExist()) { try { return getJCRProperty().getType(); } catch (Exception e) { log.warn("Unable to read property type for {}", name); } } return PropertyType.UNDEFINED; }
public void testNotNormalizedPathValue() throws RepositoryException { ValueFactory vf = superuser.getValueFactory(); Value pathValue = vf.createValue("/a/../b/./c/dd/..", PropertyType.PATH); Property p = testRootNode.setProperty(propertyName1, pathValue); assertEquals(PropertyType.PATH, p.getType()); assertEquals(pathValue.getString(), p.getValue().getString()); assertEquals(pathValue, p.getValue()); } }
private void forStringCodecProperties(final Node node, final PropertyVisitor visitor) throws RepositoryException { final PropertyIterator properties = node.getProperties(); while (properties.hasNext()) { final Property property = properties.nextProperty(); if (!property.isMultiple() && property.getType() == PropertyType.STRING && !property.getName().contains(":")) { visitor.visit(property); } } }
public void testRemoveReferenced1() throws RepositoryException { Node ref = testRootNode.addNode(nodeName1, testNodeType); ref.addMixin(mixReferenceable); superuser.save(); Node n1 = testRootNode.addNode(nodeName2, testNodeType); n1.setProperty("ref", ref); assertEquals(PropertyType.REFERENCE, n1.getProperty("ref").getType()); superuser.save(); ref.remove(); n1.remove(); superuser.save(); }
public void testSetPropertyConvertMultiValued() throws RepositoryException { Node n = testRootNode.addNode(nodeName1, "test:canSetProperty"); // must convert to long there is no other definition for this property Property p = n.setProperty("LongMultiple", new String[]{"123", "456"}); assertEquals(PropertyType.nameFromValue(PropertyType.LONG), PropertyType.nameFromValue(p.getType())); }
@Test public void setPropertyStringStringInt() throws RepositoryException { // GIVEN Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT); assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class)); // WHEN node.setProperty("test", "true", PropertyType.BOOLEAN); // THEN assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType()); }
@Test public void setPropertyStringStringArrayInt() throws RepositoryException { // GIVEN Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT); assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class)); String[] values = {"true"}; // WHEN node.setProperty("test", values, PropertyType.BOOLEAN); // THEN assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType()); }
public void testGetTypeOfPredecessors() throws RepositoryException { Node node = testRootNode.addNode(nodeName1, testNodeType); node.addMixin(mixVersionable); superuser.save(); VersionManager vMgr = superuser.getWorkspace().getVersionManager(); vMgr.checkin(node.getPath()); assertEquals(PropertyType.nameFromValue(PropertyType.REFERENCE), PropertyType.nameFromValue(node.getProperty(jcrPredecessors).getType())); }
public void testStringKey() throws Exception { assertNull(o.getString()); Map<String, Object> map = o.getProperties(); map.put("string_property", "foo"); assertEquals("foo", map.get("string_property")); assertEquals(PropertyType.STRING, node.getProperty("string_property").getType()); assertEquals("foo", node.getProperty("string_property").getString()); if (getConfig().isStateCacheDisabled()) { node.setProperty("string_property", (String)null); assertEquals(null, map.get("string_property")); } }
@Test public void setPropertyStringValueInt() throws RepositoryException { // GIVEN Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT); assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class)); // WHEN node.setProperty("test", ValueFactoryImpl.getInstance().createValue("true"), PropertyType.BOOLEAN); // THEN assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType()); }
@Test public void setPropertyStringValueArrayInt() throws RepositoryException { // GIVEN Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT); assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class)); Value[] values = {ValueFactoryImpl.getInstance().createValue("true")}; // WHEN node.setProperty("test", values, PropertyType.BOOLEAN); // THEN assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType()); }
@Test public void updateFrom534CheckSuperuserRolePermissionAreUpdated() throws Exception { // GIVEN Node roleNode = NodeUtil.createPath(userRolesSession.getRootNode(), "superuser", NodeTypes.Role.NAME); Node permissionNode = NodeUtil.createPath(roleNode, "acl_forum", NodeTypes.Role.NAME); Node wrongPermissionNode = NodeUtil.createPath(permissionNode, "0", NodeTypes.ContentNode.NAME); wrongPermissionNode.setProperty("permissions", "63"); // WHEN executeUpdatesAsIfTheCurrentlyInstalledVersionWas(Version.parseVersion("5.3.4")); // THEN assertThat(wrongPermissionNode.getProperty("permissions").getType(), CoreMatchers.is(PropertyType.LONG)); }
@Test public void addLongProperty() throws Exception { final Long propertyValue = 666L; final ValueFactory valueFactory = mock(ValueFactory.class); when(valueFactory.createValue(propertyValue)).thenReturn(new MockValue(propertyValue)); session.setValueFactory(valueFactory); final NodeOperation op = Ops.addProperty(PROPERTY_NAME, propertyValue); op.exec(rootNode, errorHandler); assertThat(rootNode, hasProperty(PROPERTY_NAME, propertyValue)); assertThat("We want to make sure the property is created with the correct type", rootNode.getProperty(PROPERTY_NAME).getType(), is(PropertyType.LONG)); }
protected DefinitionPropertyImpl exportProperty(final Property property, DefinitionNodeImpl definitionNode) throws RepositoryException { if (property.isMultiple()) { return definitionNode.addProperty(property.getName(), ValueType.fromJcrType(property.getType()), valuesFrom(property, definitionNode)); } else { final ValueImpl value = valueFrom(property, definitionNode); final DefinitionPropertyImpl targetProperty = definitionNode.addProperty(property.getName(), value); value.setParent(targetProperty); return targetProperty; } }
@Test public void testGetType() throws Exception { String stringValue = "string"; Property property = new MockProperty("test", new MockValue(stringValue), null); assertEquals(PropertyType.STRING, property.getType()); }
private static void assertVersionablePath(final VersionHistory history, final String versionablePath) throws RepositoryException { final String workspaceName = history.getSession().getWorkspace().getName(); assertTrue(history.isNodeType(MIX_REP_VERSIONABLE_PATHS)); assertTrue(history.hasProperty(workspaceName)); final Property pathProperty = history.getProperty(workspaceName); assertEquals(PropertyType.PATH, pathProperty.getType()); assertEquals(versionablePath, pathProperty.getString()); }
public void testStringRequiredTypeBoolean() throws Exception { Value stringValue = superuser.getValueFactory().createValue("true", PropertyType.STRING); Property p = node.setProperty(BOOLEAN_PROP_NAME, stringValue); assertEquals(PropertyType.BOOLEAN, p.getType()); assertEquals(PropertyType.BOOLEAN, p.getValue().getType()); assertTrue(p.getBoolean()); PropertyDefinition def = p.getDefinition(); assertEquals(PropertyType.BOOLEAN, def.getRequiredType()); assertEquals(NT_NAME, def.getDeclaringNodeType().getName()); }