diff --git a/config/alfresco/avm-services-context.xml b/config/alfresco/avm-services-context.xml index 2eed041490..3168fd869c 100644 --- a/config/alfresco/avm-services-context.xml +++ b/config/alfresco/avm-services-context.xml @@ -286,6 +286,9 @@ + + + diff --git a/config/alfresco/node-services-context.xml b/config/alfresco/node-services-context.xml index d14d9c3a56..fccc3b0805 100644 --- a/config/alfresco/node-services-context.xml +++ b/config/alfresco/node-services-context.xml @@ -15,6 +15,15 @@ + + + + + + + + + @@ -27,6 +36,7 @@ + nodeRefPropertyInterceptor mlPropertyInterceptor diff --git a/source/java/org/alfresco/filesys/smb/server/IPCHandler.java b/source/java/org/alfresco/filesys/smb/server/IPCHandler.java index 3dc3a5d6f9..aa300b6de5 100644 --- a/source/java/org/alfresco/filesys/smb/server/IPCHandler.java +++ b/source/java/org/alfresco/filesys/smb/server/IPCHandler.java @@ -24,11 +24,15 @@ */ package org.alfresco.filesys.smb.server; +import java.io.FileNotFoundException; import java.io.IOException; +import org.alfresco.filesys.server.filesys.FileInfo; import org.alfresco.filesys.server.filesys.NetworkFile; +import org.alfresco.filesys.server.filesys.PathNotFoundException; import org.alfresco.filesys.server.filesys.TooManyFilesException; import org.alfresco.filesys.server.filesys.TreeConnection; +import org.alfresco.filesys.server.filesys.UnsupportedInfoLevelException; import org.alfresco.filesys.smb.PacketType; import org.alfresco.filesys.smb.SMBStatus; import org.alfresco.filesys.smb.TransactionNames; @@ -186,6 +190,12 @@ class IPCHandler DCERPCHandler.processDCERPCRequest(sess, vc, tbuf, outPkt); break; + // Query file information via handle + + case PacketType.Trans2QueryFile: + procTrans2QueryFile(sess, vc, tbuf, outPkt); + break; + // Unknown command default: @@ -661,4 +671,134 @@ class IPCHandler sess.sendResponseSMB(outPkt); } + + /** + * Process a transact2 query file information (via handle) request. + * + * @param sess SMBSrvSession + * @param vc VirtualCircuit + * @param tbuf Transaction request details + * @param outPkt SMBSrvPacket + * @exception java.io.IOException The exception description. + * @exception org.alfresco.aifs.smb.SMBSrvException SMB protocol exception + */ + protected static final void procTrans2QueryFile(SMBSrvSession sess, VirtualCircuit vc, SrvTransactBuffer tbuf, SMBSrvPacket outPkt) + throws java.io.IOException, SMBSrvException { + + // Get the tree connection details + + int treeId = tbuf.getTreeId(); + TreeConnection conn = vc.findConnection(treeId); + + if (conn == null) { + sess.sendErrorResponseSMB(SMBStatus.NTInvalidParameter, SMBStatus.DOSInvalidDrive, SMBStatus.ErrDos); + return; + } + + // Check if the user has the required access permission + + if (conn.hasReadAccess() == false) { + + // User does not have the required access rights + + sess.sendErrorResponseSMB(SMBStatus.NTAccessDenied, SMBStatus.DOSAccessDenied, SMBStatus.ErrDos); + return; + } + + // Get the file id and query path information level + + DataBuffer paramBuf = tbuf.getParameterBuffer(); + + int fid = paramBuf.getShort(); + int infoLevl = paramBuf.getShort(); + + // Get the file details via the file id + + NetworkFile netFile = conn.findFile(fid); + + if (netFile == null) { + sess.sendErrorResponseSMB(SMBStatus.DOSInvalidHandle, SMBStatus.ErrDos); + return; + } + + // Debug + + if (logger.isDebugEnabled() && sess.hasDebug(SMBSrvSession.DBG_IPC)) + logger.debug("IPC$ Query File - level=0x" + Integer.toHexString(infoLevl) + ", fid=" + fid + ", name=" + netFile.getFullName()); + + // Access the shared device disk interface + + try { + + // Set the return parameter count, so that the data area position can be calculated. + + outPkt.setParameterCount(10); + + // Pack the file information into the data area of the transaction reply + + byte[] buf = outPkt.getBuffer(); + int prmPos = DataPacker.longwordAlign(outPkt.getByteOffset()); + int dataPos = prmPos + 4; + + // Pack the return parametes, EA error offset + + outPkt.setPosition(prmPos); + outPkt.packWord(0); + + // Create a data buffer using the SMB packet. The response should always fit into a single + // reply packet. + + DataBuffer replyBuf = new DataBuffer(buf, dataPos, buf.length - dataPos); + + // Build the file information from the network file details + + FileInfo fileInfo = new FileInfo(netFile.getName(), netFile.getFileSize(), netFile.getFileAttributes()); + + fileInfo.setAccessDateTime(netFile.getAccessDate()); + fileInfo.setCreationDateTime(netFile.getCreationDate()); + fileInfo.setModifyDateTime(netFile.getModifyDate()); + fileInfo.setChangeDateTime(netFile.getModifyDate()); + + fileInfo.setFileId(netFile.getFileId()); + + // Pack the file information into the return data packet + + int dataLen = QueryInfoPacker.packInfo(fileInfo, replyBuf, infoLevl, true); + + // Check if any data was packed, if not then the information level is not supported + + if (dataLen == 0) { + sess.sendErrorResponseSMB(SMBStatus.NTInvalidParameter, SMBStatus.SRVNonSpecificError, SMBStatus.ErrSrv); + return; + } + + SMBSrvTransPacket.initTransactReply(outPkt, 2, prmPos, dataLen, dataPos); + outPkt.setByteCount(replyBuf.getPosition() - outPkt.getByteOffset()); + + // Send the transact reply + + sess.sendResponseSMB(outPkt); + } + catch (FileNotFoundException ex) { + + // Requested file does not exist + + sess.sendErrorResponseSMB(SMBStatus.NTObjectNotFound, SMBStatus.DOSFileNotFound, SMBStatus.ErrDos); + return; + } + catch (PathNotFoundException ex) { + + // Requested path does not exist + + sess.sendErrorResponseSMB(SMBStatus.NTObjectPathNotFound, SMBStatus.DOSFileNotFound, SMBStatus.ErrDos); + return; + } + catch (UnsupportedInfoLevelException ex) { + + // Requested information level is not supported + + sess.sendErrorResponseSMB(SMBStatus.NTInvalidParameter, SMBStatus.SRVNonSpecificError, SMBStatus.ErrSrv); + return; + } + } } \ No newline at end of file diff --git a/source/java/org/alfresco/linkvalidation/LinkValidationAction.java b/source/java/org/alfresco/linkvalidation/LinkValidationAction.java index 08016198bb..6ceb99905b 100644 --- a/source/java/org/alfresco/linkvalidation/LinkValidationAction.java +++ b/source/java/org/alfresco/linkvalidation/LinkValidationAction.java @@ -178,6 +178,7 @@ public class LinkValidationAction extends ActionExecuterAbstractBase } catch (Throwable err) { + // capture the error in the report if (report != null) { report.setError(err); @@ -187,6 +188,12 @@ public class LinkValidationAction extends ActionExecuterAbstractBase report = new LinkValidationReport(storeName, webappName, err); } + // set the monitor object as completed + if (monitor != null) + { + monitor.setDone(true); + } + logger.error("Link Validation Error: ", err); } diff --git a/source/java/org/alfresco/repo/action/evaluator/ComparePropertyValueEvaluatorTest.java b/source/java/org/alfresco/repo/action/evaluator/ComparePropertyValueEvaluatorTest.java index c6123dd753..d01d1dcdae 100644 --- a/source/java/org/alfresco/repo/action/evaluator/ComparePropertyValueEvaluatorTest.java +++ b/source/java/org/alfresco/repo/action/evaluator/ComparePropertyValueEvaluatorTest.java @@ -108,7 +108,7 @@ public class ComparePropertyValueEvaluatorTest extends BaseSpringTest + System.currentTimeMillis()); this.rootNodeRef = this.nodeService.getRootNode(this.testStoreRef); - this.nodeValue = new NodeRef(this.testStoreRef, "1234"); + this.nodeValue = this.rootNodeRef; this.beforeDateValue = new Date(); Thread.sleep(2000); diff --git a/source/java/org/alfresco/repo/avm/AVMCrawlTestP.java b/source/java/org/alfresco/repo/avm/AVMCrawlTestP.java index 2149cebde8..8d1df80d8c 100644 --- a/source/java/org/alfresco/repo/avm/AVMCrawlTestP.java +++ b/source/java/org/alfresco/repo/avm/AVMCrawlTestP.java @@ -41,9 +41,9 @@ public class AVMCrawlTestP extends AVMServiceTestBase */ public void testCrawl() { - int n = 3; // Number of Threads. - int m = 10; // How many multiples of content to start with. - long runTime = 18000000; // 6 hours. + int n = 4; // Number of Threads. + int m = 2; // How many multiples of content to start with. + long runTime = 3600000; // 1 Hour. . fService.purgeStore("main"); BulkLoader loader = new BulkLoader(); loader.setAvmService(fService); diff --git a/source/java/org/alfresco/repo/avm/AVMExpiredContentProcessor.java b/source/java/org/alfresco/repo/avm/AVMExpiredContentProcessor.java index e99217ff7d..5ce429af86 100644 --- a/source/java/org/alfresco/repo/avm/AVMExpiredContentProcessor.java +++ b/source/java/org/alfresco/repo/avm/AVMExpiredContentProcessor.java @@ -48,6 +48,7 @@ import org.alfresco.sandbox.SandboxConstants; import org.alfresco.service.cmr.avm.AVMNodeDescriptor; import org.alfresco.service.cmr.avm.AVMService; import org.alfresco.service.cmr.avm.AVMStoreDescriptor; +import org.alfresco.service.cmr.avm.locking.AVMLock; import org.alfresco.service.cmr.avm.locking.AVMLockingService; import org.alfresco.service.cmr.avmsync.AVMSyncService; import org.alfresco.service.cmr.dictionary.DataTypeDefinition; @@ -88,6 +89,7 @@ public class AVMExpiredContentProcessor protected AVMService avmService; protected AVMSyncService avmSyncService; protected AVMService avmLockingAwareService; + protected AVMLockingService avmLockingService; protected NodeService nodeService; protected WorkflowService workflowService; protected PersonService personService; @@ -120,6 +122,11 @@ public class AVMExpiredContentProcessor this.avmService = avmService; } + public void setAvmLockingService(AVMLockingService avmLockingService) + { + this.avmLockingService = avmLockingService; + } + public void setAvmSyncService(AVMSyncService avmSyncService) { this.avmSyncService = avmSyncService; @@ -321,35 +328,53 @@ public class AVMExpiredContentProcessor if (expirationDate != null && expirationDate.before(now)) { - // get the map of expired content for the store - Map> storeExpiredContent = this.expiredContent.get(storeName); - if (storeExpiredContent == null) - { - storeExpiredContent = new HashMap>(4); - this.expiredContent.put(storeName, storeExpiredContent); - } - - // get the list of expired content for the last modifier of the node - String modifier = node.getLastModifier(); - List userExpiredContent = storeExpiredContent.get(modifier); - if (userExpiredContent == null) - { - userExpiredContent = new ArrayList(4); - storeExpiredContent.put(modifier, userExpiredContent); - } - - // add the content to the user's list for the current store - userExpiredContent.add(nodePath); - + // before doing anything else see whether the item is locked by any user, + // if it is then just log a warning messge and wait until the next time around + String[] splitPath = nodePath.split(":"); + AVMLock lock = this.avmLockingService.getLock(storeName, splitPath[1]); + if (logger.isDebugEnabled()) - logger.debug("Added " + nodePath + " to " + modifier + "'s list of expired content"); + logger.debug("lock details for '" + nodePath + "': " + lock); + + if (lock == null) + { + // get the map of expired content for the store + Map> storeExpiredContent = this.expiredContent.get(storeName); + if (storeExpiredContent == null) + { + storeExpiredContent = new HashMap>(4); + this.expiredContent.put(storeName, storeExpiredContent); + } - // reset the expiration date - this.avmService.setNodeProperty(nodePath, WCMAppModel.PROP_EXPIRATIONDATE, - new PropertyValue(DataTypeDefinition.DATETIME, null)); - - if (logger.isDebugEnabled()) - logger.debug("Reset expiration date for: " + nodePath); + // get the list of expired content for the last modifier of the node + String modifier = node.getLastModifier(); + List userExpiredContent = storeExpiredContent.get(modifier); + if (userExpiredContent == null) + { + userExpiredContent = new ArrayList(4); + storeExpiredContent.put(modifier, userExpiredContent); + } + + // add the content to the user's list for the current store + userExpiredContent.add(nodePath); + + if (logger.isDebugEnabled()) + logger.debug("Added " + nodePath + " to " + modifier + "'s list of expired content"); + + // reset the expiration date + this.avmService.setNodeProperty(nodePath, WCMAppModel.PROP_EXPIRATIONDATE, + new PropertyValue(DataTypeDefinition.DATETIME, null)); + + if (logger.isDebugEnabled()) + logger.debug("Reset expiration date for: " + nodePath); + } + else + { + if (logger.isWarnEnabled()) + { + logger.warn("ignoring '" + nodePath + "', although it has expired, it's currently locked"); + } + } } } } diff --git a/source/java/org/alfresco/repo/avm/AVMNodeService.java b/source/java/org/alfresco/repo/avm/AVMNodeService.java index d2a95ae88e..1f7b2da59b 100644 --- a/source/java/org/alfresco/repo/avm/AVMNodeService.java +++ b/source/java/org/alfresco/repo/avm/AVMNodeService.java @@ -708,14 +708,7 @@ public class AVMNodeService extends AbstractNodeServiceImpl implements NodeServi { return true; } - try - { - return fAVMService.hasAspect(version, path, aspectTypeQName); - } - catch (AVMNotFoundException e) - { - throw new InvalidNodeRefException(nodeRef); - } + return fAVMService.hasAspect(version, path, aspectTypeQName); } private static QName [] fgBuiltinAspects = new QName[] { ContentModel.ASPECT_AUDITABLE, diff --git a/source/java/org/alfresco/repo/avm/AVMServiceTest.java b/source/java/org/alfresco/repo/avm/AVMServiceTest.java index f788bb9fbb..f69fa66117 100644 --- a/source/java/org/alfresco/repo/avm/AVMServiceTest.java +++ b/source/java/org/alfresco/repo/avm/AVMServiceTest.java @@ -101,6 +101,21 @@ import org.alfresco.util.Pair; */ public class AVMServiceTest extends AVMServiceTestBase { + public void testSpacesInStoreNames() + { + try + { + fService.createStore("I have spaces"); + fService.createFile("I have spaces:/", "in my name.txt").close(); + assertNotNull(fService.lookup(-1, "I have spaces:/in my name.txt")); + } + catch (Exception e) + { + e.printStackTrace(); + fail(); + } + } + public void testHeadPathsInLayers() { try diff --git a/source/java/org/alfresco/repo/avm/AVMStoreImpl.java b/source/java/org/alfresco/repo/avm/AVMStoreImpl.java index e6ab1900b6..956b86e879 100644 --- a/source/java/org/alfresco/repo/avm/AVMStoreImpl.java +++ b/source/java/org/alfresco/repo/avm/AVMStoreImpl.java @@ -291,11 +291,13 @@ public class AVMStoreImpl implements AVMStore, Serializable } VersionRoot versionRoot = new VersionRootImpl(this, fRoot, - fNextVersionID, + fNextVersionID++, System.currentTimeMillis(), user, tag, description); + // Another embarassing flush needed. + AVMDAOs.Instance().fAVMNodeDAO.flush(); AVMDAOs.Instance().fVersionRootDAO.save(versionRoot); for (AVMNode node : layeredNodes) { @@ -308,7 +310,6 @@ public class AVMStoreImpl implements AVMStore, Serializable } } // Increment the version id. - fNextVersionID++; return snapShotMap; } @@ -462,6 +463,8 @@ public class AVMStoreImpl implements AVMStore, Serializable RawServices.Instance().getMimetypeService().guessMimetype(name), -1, "UTF-8")); + // Yet another flush. + AVMDAOs.Instance().fAVMNodeDAO.flush(); ContentWriter writer = createContentWriter(AVMNodeConverter.ExtendAVMPath(path, name)); writer.putContent(data); } diff --git a/source/java/org/alfresco/repo/node/NodeRefPropertyMethodInterceptor.java b/source/java/org/alfresco/repo/node/NodeRefPropertyMethodInterceptor.java new file mode 100644 index 0000000000..5427904496 --- /dev/null +++ b/source/java/org/alfresco/repo/node/NodeRefPropertyMethodInterceptor.java @@ -0,0 +1,379 @@ +/* + * Copyright (C) 2005-2007 Alfresco Software Limited. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program 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 General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + * As a special exception to the terms and conditions of version 2.0 of + * the GPL, you may redistribute this Program in connection with Free/Libre + * and Open Source Software ("FLOSS") applications as described in Alfresco's + * FLOSS exception. You should have recieved a copy of the text describing + * the FLOSS exception, and it is also available here: + * http://www.alfresco.com/legal/licensing" + */ +package org.alfresco.repo.node; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.alfresco.model.ContentModel; +import org.alfresco.service.cmr.dictionary.DataTypeDefinition; +import org.alfresco.service.cmr.dictionary.DictionaryService; +import org.alfresco.service.cmr.dictionary.PropertyDefinition; +import org.alfresco.service.cmr.repository.NodeRef; +import org.alfresco.service.cmr.repository.NodeService; +import org.alfresco.service.cmr.repository.datatype.DefaultTypeConverter; +import org.alfresco.service.cmr.repository.datatype.TypeConversionException; +import org.alfresco.service.namespace.QName; +import org.aopalliance.intercept.MethodInterceptor; +import org.aopalliance.intercept.MethodInvocation; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * A method interceptor to clean up node ref properties as they are passed in and out of the node service. For + * getProperty and getProperies calls invalid node refs are removed from the returned set (they appear to have be + * cleaned up). For setProperty and setProperties calls invalid node refs are removed and thus not set. It only + * considers properties of type d:noderef. + * + * @author andyh + */ +public class NodeRefPropertyMethodInterceptor implements MethodInterceptor +{ + private static Log logger = LogFactory.getLog(NodeRefPropertyMethodInterceptor.class); + + private boolean filterOnGet = true; + + private boolean filterOnSet = true; + + private DictionaryService dictionaryService; + + private NodeService nodeService; + + public boolean isFilterOnGet() + { + return filterOnGet; + } + + public void setFilterOnGet(boolean filterOnGet) + { + this.filterOnGet = filterOnGet; + } + + public boolean isFilterOnSet() + { + return filterOnSet; + } + + public void setFilterOnSet(boolean filterOnSet) + { + this.filterOnSet = filterOnSet; + } + + public void setDictionaryService(DictionaryService dictionaryService) + { + this.dictionaryService = dictionaryService; + } + + public void setNodeService(NodeService nodeService) + { + this.nodeService = nodeService; + } + + @SuppressWarnings("unchecked") + public Object invoke(MethodInvocation invocation) throws Throwable + { + String methodName = invocation.getMethod().getName(); + + // We are going to change the method arguments as we proceed - so we keep them to set the references back at the + // end + // Not sure if there would be any side effect but we guard against it in any case. + // Audit for example will see the correct values on exit + // org.springframework.aop.framework.ReflectiveMethodInvocation does not do any special wrapping and this is + // fine + + Object[] args = invocation.getArguments(); + Object[] in = new Object[args.length]; + System.arraycopy(args, 0, in, 0, args.length); + invocation.getStaticPart(); + + try + { + if (methodName.equals("addAspect")) + { + if (filterOnSet) + { + NodeRef nodeRef = (NodeRef) args[0]; + QName aspectType = (QName) args[1]; + Map newProperties = (Map) args[2]; + + if (newProperties == null) + { + args[2] = newProperties; + return invocation.proceed(); + } + else + { + + Map convertedProperties = new HashMap(newProperties.size() * 2); + for (Map.Entry entry : newProperties.entrySet()) + { + QName propertyQName = entry.getKey(); + Serializable value = entry.getValue(); + value = getValue(propertyQName, value); + convertedProperties.put(propertyQName, value); + } + args[2] = convertedProperties; + return invocation.proceed(); + } + } + else + { + return invocation.proceed(); + } + } + else if (methodName.equals("createNode") & (args.length == 5)) + { + if (filterOnSet) + { + NodeRef parentRef = (NodeRef) args[0]; + QName assocTypeQName = (QName) args[1]; + QName assocQName = (QName) args[2]; + QName nodeTypeQName = (QName) args[3]; + Map newProperties = (Map) args[4]; + if (newProperties == null) + { + args[4] = newProperties; + return invocation.proceed(); + } + else + { + + Map convertedProperties = new HashMap(newProperties.size() * 2); + for (Map.Entry entry : newProperties.entrySet()) + { + QName propertyQName = entry.getKey(); + Serializable value = entry.getValue(); + value = getValue(propertyQName, value); + convertedProperties.put(propertyQName, value); + } + args[4] = newProperties; + return invocation.proceed(); + } + } + else + { + return invocation.proceed(); + } + } + else if (methodName.equals("getProperty")) + { + if (filterOnGet) + { + NodeRef nodeRef = (NodeRef) args[0]; + QName propertyQName = (QName) args[1]; + + Serializable value = (Serializable) invocation.proceed(); + return getValue(propertyQName, value); + } + else + { + return invocation.proceed(); + } + } + else if (methodName.equals("getProperties")) + { + if (filterOnGet) + { + NodeRef nodeRef = (NodeRef) args[0]; + + Map properties = (Map) invocation.proceed(); + Map convertedProperties = new HashMap(properties.size() * 2); + for (Map.Entry entry : properties.entrySet()) + { + QName propertyQName = entry.getKey(); + Serializable value = entry.getValue(); + Serializable convertedValue = getValue(propertyQName, value); + convertedProperties.put(propertyQName, convertedValue); + } + return convertedProperties; + } + else + { + return invocation.proceed(); + } + } + else if (methodName.equals("setProperties")) + { + if (filterOnSet) + { + NodeRef nodeRef = (NodeRef) args[0]; + + Map newProperties = (Map) args[1]; + Map convertedProperties = new HashMap(newProperties.size() * 2); + for (Map.Entry entry : newProperties.entrySet()) + { + QName propertyQName = entry.getKey(); + Serializable value = entry.getValue(); + value = getValue(propertyQName, value); + convertedProperties.put(propertyQName, value); + } + args[1] = convertedProperties; + return invocation.proceed(); + } + else + { + return invocation.proceed(); + } + } + else if (methodName.equals("setProperty")) + { + if (filterOnSet) + { + NodeRef nodeRef = (NodeRef) args[0]; + QName propertyQName = (QName) args[1]; + Serializable value = (Serializable) args[2]; + value = getValue(propertyQName, value); + args[2] = value; + return invocation.proceed(); + } + else + { + return invocation.proceed(); + } + } + else + { + return invocation.proceed(); + } + + } + finally + { + System.arraycopy(in, 0, args, 0, in.length); + } + } + + /** + * Remove unknown node ref values Remove unknowen categories - the node will be removed if it does exist and it is + * not a category + * + * @param propertyQName + * @param inboundValue + * @return + */ + private Serializable getValue(QName propertyQName, Serializable inboundValue) + { + PropertyDefinition propertyDef = this.dictionaryService.getProperty(propertyQName); + if (propertyDef == null) + { + return inboundValue; + } + else + { + if ((propertyDef.getDataType().getName().equals(DataTypeDefinition.NODE_REF)) || (propertyDef.getDataType().getName().equals(DataTypeDefinition.CATEGORY))) + { + if (inboundValue instanceof Collection) + { + Collection in = (Collection) inboundValue; + ArrayList out = new ArrayList(in.size()); + for (Object o : in) + { + Serializable value = (Serializable) o; + if (value == null) + { + out.add(null); + } + else + { + try + { + NodeRef test = DefaultTypeConverter.INSTANCE.convert(NodeRef.class, value); + if (nodeService.exists(test)) + { + if (propertyDef.getDataType().getName().equals(DataTypeDefinition.CATEGORY)) + { + QName type = nodeService.getType(test); + if (dictionaryService.isSubClass(type, ContentModel.TYPE_CATEGORY)) + { + out.add(test); + } + } + else + { + out.add(test); + } + } + } + catch (TypeConversionException e) + { + // Catch and continue + } + } + } + return out; + } + else + { + if (inboundValue == null) + { + return inboundValue; + } + else + { + try + { + NodeRef test = DefaultTypeConverter.INSTANCE.convert(NodeRef.class, inboundValue); + if (nodeService.exists(test)) + { + if (propertyDef.getDataType().getName().equals(DataTypeDefinition.CATEGORY)) + { + QName type = nodeService.getType(test); + if (dictionaryService.isSubClass(type, ContentModel.TYPE_CATEGORY)) + { + return inboundValue; + } + else + { + return null; + } + } + else + { + return inboundValue; + } + } + else + { + return null; + } + } + + catch (TypeConversionException e) + { + return null; + } + } + } + } + else + { + return inboundValue; + } + } + } +} diff --git a/source/java/org/alfresco/repo/node/NodeRefPropertyMethodInterceptorTest.java b/source/java/org/alfresco/repo/node/NodeRefPropertyMethodInterceptorTest.java new file mode 100644 index 0000000000..f5f0d216fe --- /dev/null +++ b/source/java/org/alfresco/repo/node/NodeRefPropertyMethodInterceptorTest.java @@ -0,0 +1,1875 @@ +/* + * Copyright (C) 2005-2007 Alfresco Software Limited. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program 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 General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + * As a special exception to the terms and conditions of version 2.0 of + * the GPL, you may redistribute this Program in connection with Free/Libre + * and Open Source Software ("FLOSS") applications as described in Alfresco's + * FLOSS exception. You should have recieved a copy of the text describing + * the FLOSS exception, and it is also available here: + * http://www.alfresco.com/legal/licensing" + */ +package org.alfresco.repo.node; + +import java.io.InputStream; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; + +import org.alfresco.model.ContentModel; +import org.alfresco.repo.dictionary.DictionaryDAO; +import org.alfresco.repo.dictionary.M2Model; +import org.alfresco.repo.security.authentication.AuthenticationComponent; +import org.alfresco.service.cmr.repository.NodeRef; +import org.alfresco.service.cmr.repository.NodeService; +import org.alfresco.service.cmr.repository.StoreRef; +import org.alfresco.service.namespace.QName; +import org.alfresco.util.BaseSpringTest; + +public class NodeRefPropertyMethodInterceptorTest extends BaseSpringTest +{ + + private static final String TEST_NAMESPACE = "http://www.alfresco.org/test/NodeRefTestModel"; + + private QName testType = QName.createQName(TEST_NAMESPACE, "testType"); + + private QName categoryAspect = QName.createQName(TEST_NAMESPACE, "singleCategory"); + + private QName categoriesAspect = QName.createQName(TEST_NAMESPACE, "multipleCategories"); + + private QName noderefAspect = QName.createQName(TEST_NAMESPACE, "singleNodeRef"); + + private QName noderefsAspect = QName.createQName(TEST_NAMESPACE, "multipleNodeRefs"); + + private QName aspectCategoryProp = QName.createQName(TEST_NAMESPACE, "category"); + + private QName aspectCategoriesProp = QName.createQName(TEST_NAMESPACE, "categories"); + + private QName aspectNoderefProp = QName.createQName(TEST_NAMESPACE, "noderef"); + + private QName aspectNoderefsProp = QName.createQName(TEST_NAMESPACE, "noderefs"); + + private QName typeCategoryProp = QName.createQName(TEST_NAMESPACE, "category1"); + + private QName typeCategoriesProp = QName.createQName(TEST_NAMESPACE, "categories1"); + + private QName typeNoderefProp = QName.createQName(TEST_NAMESPACE, "noderef1"); + + private QName typeNoderefsProp = QName.createQName(TEST_NAMESPACE, "noderefs1"); + + private NodeService mlAwareNodeService; + + private NodeService nodeService; + + private NodeRef rootNodeRef; + + private AuthenticationComponent authenticationComponent; + + private DictionaryDAO dictionaryDAO; + + public NodeRefPropertyMethodInterceptorTest() + { + super(); + } + + @Override + protected void onSetUpInTransaction() throws Exception + { + super.onSetUpInTransaction(); + mlAwareNodeService = (NodeService) applicationContext.getBean("mlAwareNodeService"); + nodeService = (NodeService) applicationContext.getBean("nodeService"); + dictionaryDAO = (DictionaryDAO) applicationContext.getBean("dictionaryDAO"); + + authenticationComponent = (AuthenticationComponent) applicationContext.getBean("authenticationComponent"); + + authenticationComponent.setSystemUserAsCurrentUser(); + + ClassLoader cl = BaseNodeServiceTest.class.getClassLoader(); + InputStream modelStream = cl.getResourceAsStream("org/alfresco/repo/node/NodeRefTestModel.xml"); + assertNotNull(modelStream); + M2Model model = M2Model.createModel(modelStream); + dictionaryDAO.putModel(model); + + StoreRef storeRef = nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, "Test_" + System.currentTimeMillis()); + rootNodeRef = nodeService.getRootNode(storeRef); + + } + + @Override + protected void onTearDownInTransaction() throws Exception + { + try + { + authenticationComponent.clearCurrentSecurityContext(); + } + catch (Throwable e) + { + // do nothing + } + super.onTearDownInTransaction(); + } + + public void testOnRead() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + // Add aspect + + mlAwareNodeService.addAspect(n1, categoryAspect, null); + mlAwareNodeService.addAspect(n1, categoriesAspect, null); + mlAwareNodeService.addAspect(n1, noderefAspect, null); + mlAwareNodeService.addAspect(n1, noderefsAspect, null); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + + // Set null property + + mlAwareNodeService.setProperty(n1, aspectCategoryProp, null); + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, null); + mlAwareNodeService.setProperty(n1, aspectNoderefProp, null); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, null); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + + // Set invalid + + mlAwareNodeService.setProperty(n1, aspectCategoryProp, invalidNodeRef); + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, invalidNodeRef); + mlAwareNodeService.setProperty(n1, aspectNoderefProp, invalidNodeRef); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, invalidNodeRef); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + + // Set valid node ref + + mlAwareNodeService.setProperty(n1, aspectCategoryProp, rootNodeRef); + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, rootNodeRef); + mlAwareNodeService.setProperty(n1, aspectNoderefProp, rootNodeRef); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, rootNodeRef); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + + // Set valid cat + + mlAwareNodeService.setProperty(n1, aspectCategoryProp, cat); + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, cat); + mlAwareNodeService.setProperty(n1, aspectNoderefProp, cat); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, cat); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + + // Set empty list + + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, new ArrayList()); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, new ArrayList()); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + + // Set invalid noderef in list + + ArrayList cats = new ArrayList(); + cats.add(invalidNodeRef); + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, cats); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, cats); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + + // Set valid ref in list + + cats = new ArrayList(); + cats.add(rootNodeRef); + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, cats); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, cats); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + + // set valid cat in list + + cats = new ArrayList(); + cats.add(cat); + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, cats); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, cats); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + + // Test list with invalid, noderef and cat + + cats = new ArrayList(); + cats.add(rootNodeRef); + cats.add(invalidNodeRef); + cats.add(cat); + mlAwareNodeService.setProperty(n1, aspectCategoriesProp, cats); + mlAwareNodeService.setProperty(n1, aspectNoderefsProp, cats); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(3, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(3, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(3, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(3, ((Collection) mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + + } + + public void testAddAspectNull() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, null); + nodeService.addAspect(n1, categoriesAspect, null); + nodeService.addAspect(n1, noderefAspect, null); + nodeService.addAspect(n1, noderefsAspect, null); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testAddAspectNullValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + properties1.put(aspectCategoryProp, null); + properties2.put(aspectCategoriesProp, null); + properties3.put(aspectNoderefProp, null); + properties4.put(aspectNoderefsProp, null); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testAddAspectInvalidValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef testInvalid = invalidNodeRef; + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + properties1.put(aspectCategoryProp, invalidNodeRef); + properties2.put(aspectCategoriesProp, invalidNodeRef); + properties3.put(aspectNoderefProp, invalidNodeRef); + properties4.put(aspectNoderefsProp, invalidNodeRef); + + assertEquals(testInvalid, invalidNodeRef); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testAddAspectValidNode() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + properties1.put(aspectCategoryProp, rootNodeRef); + properties2.put(aspectCategoriesProp, rootNodeRef); + properties3.put(aspectNoderefProp, rootNodeRef); + properties4.put(aspectNoderefsProp, rootNodeRef); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testAddAspectValidCategory() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + properties1.put(aspectCategoryProp, cat); + properties2.put(aspectCategoriesProp, cat); + properties3.put(aspectNoderefProp, cat); + properties4.put(aspectNoderefsProp, cat); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testAddAspectEmptyList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + ArrayList vals = new ArrayList(); + properties2.put(aspectCategoriesProp, vals); + properties4.put(aspectNoderefsProp, vals); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testAddAspectInvalidList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + ArrayList vals = new ArrayList(); + vals.add(invalidNodeRef); + properties2.put(aspectCategoriesProp, vals); + properties4.put(aspectNoderefsProp, vals); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertEquals(1, properties4.size()); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testAddAspectNodeRefList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + ArrayList vals = new ArrayList(); + vals.add(rootNodeRef); + properties2.put(aspectCategoriesProp, vals); + properties4.put(aspectNoderefsProp, vals); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testAddAspectCatList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + ArrayList vals = new ArrayList(); + vals.add(cat); + properties2.put(aspectCategoriesProp, vals); + properties4.put(aspectNoderefsProp, vals); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testAddAspectMixedList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + + NodeRef n1 = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER).getChildRef(); + + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties1 = new HashMap(); + HashMap properties2 = new HashMap(); + HashMap properties3 = new HashMap(); + HashMap properties4 = new HashMap(); + ArrayList vals = new ArrayList(); + vals.add(cat); + vals.add(rootNodeRef); + vals.add(invalidNodeRef); + properties2.put(aspectCategoriesProp, vals); + properties4.put(aspectNoderefsProp, vals); + + // Add aspect + + nodeService.addAspect(n1, categoryAspect, properties1); + nodeService.addAspect(n1, categoriesAspect, properties2); + nodeService.addAspect(n1, noderefAspect, properties3); + nodeService.addAspect(n1, noderefsAspect, properties4); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(2, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(2, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testCreateNodeNull() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, null).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testCreateNodeNullValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + properties.put(aspectCategoryProp, null); + properties.put(aspectCategoriesProp, null); + properties.put(aspectNoderefProp, null); + properties.put(aspectNoderefsProp, null); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testCreateNodeInvalidValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + properties.put(aspectCategoryProp, invalidNodeRef); + properties.put(aspectCategoriesProp, invalidNodeRef); + properties.put(aspectNoderefProp, invalidNodeRef); + properties.put(aspectNoderefsProp, invalidNodeRef); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testCreateNodeNodeRefValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + properties.put(aspectCategoryProp, rootNodeRef); + properties.put(aspectCategoriesProp, rootNodeRef); + properties.put(aspectNoderefProp, rootNodeRef); + properties.put(aspectNoderefsProp, rootNodeRef); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testCreateNodeCatValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + properties.put(aspectCategoryProp, cat); + properties.put(aspectCategoriesProp, cat); + properties.put(aspectNoderefProp, cat); + properties.put(aspectNoderefsProp, cat); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(aspectNoderefsProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoryProp)); + assertNotNull(nodeService.getProperty(n1, aspectCategoriesProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefProp)); + assertNotNull(nodeService.getProperty(n1, aspectNoderefsProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + } + + public void testCreateEmptyListValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + ArrayList val = new ArrayList(); + + properties.put(aspectCategoriesProp, val); + properties.put(aspectNoderefsProp, val); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testCreateInvalidListValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + ArrayList val = new ArrayList(); + val.add(invalidNodeRef); + + properties.put(aspectCategoriesProp, val); + properties.put(aspectNoderefsProp, val); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testCreateNodeRefListValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + ArrayList val = new ArrayList(); + val.add(rootNodeRef); + + properties.put(aspectCategoriesProp, val); + properties.put(aspectNoderefsProp, val); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testCreateCatListValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + ArrayList val = new ArrayList(); + val.add(cat); + + properties.put(aspectCategoriesProp, val); + properties.put(aspectNoderefsProp, val); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testCreateMixedListValues() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + HashMap properties = new HashMap(); + ArrayList val = new ArrayList(); + val.add(invalidNodeRef); + val.add(rootNodeRef); + val.add(cat); + + properties.put(aspectCategoriesProp, val); + properties.put(aspectNoderefsProp, val); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), ContentModel.TYPE_FOLDER, properties).getChildRef(); + + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(2, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, aspectCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, aspectNoderefsProp)); + assertEquals(2, ((Collection) mlAwareNodeService.getProperty(n1, aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(aspectCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(aspectNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperties(n1).get(aspectNoderefsProp)).size()); + } + + public void testSetPropertyNull() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + nodeService.setProperty(n1, typeCategoryProp, null); + nodeService.setProperty(n1, typeCategoriesProp, null); + nodeService.setProperty(n1, typeNoderefProp, null); + nodeService.setProperty(n1, typeNoderefsProp, null); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + } + + public void testSetPropertyInvalid() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + nodeService.setProperty(n1, typeCategoryProp, invalidNodeRef); + nodeService.setProperty(n1, typeCategoriesProp, invalidNodeRef); + nodeService.setProperty(n1, typeNoderefProp, invalidNodeRef); + nodeService.setProperty(n1, typeNoderefsProp, invalidNodeRef); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + } + + public void testSetPropertyNodeRef() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + nodeService.setProperty(n1, typeCategoryProp, rootNodeRef); + nodeService.setProperty(n1, typeCategoriesProp, rootNodeRef); + nodeService.setProperty(n1, typeNoderefProp, rootNodeRef); + nodeService.setProperty(n1, typeNoderefsProp, rootNodeRef); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNotNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertyCat() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + nodeService.setProperty(n1, typeCategoryProp, cat); + nodeService.setProperty(n1, typeCategoriesProp, cat); + nodeService.setProperty(n1, typeNoderefProp, cat); + nodeService.setProperty(n1, typeNoderefsProp, cat); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + + } + + public void testSetPropertyEmptyList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + ArrayList values = new ArrayList(); + + nodeService.setProperty(n1, typeCategoriesProp, values); + nodeService.setProperty(n1, typeNoderefsProp, values); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertyNodeRefList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + ArrayList values = new ArrayList(); + values.add(rootNodeRef); + + nodeService.setProperty(n1, typeCategoriesProp, values); + nodeService.setProperty(n1, typeNoderefsProp, values); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertyCatList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + ArrayList values = new ArrayList(); + values.add(cat); + + nodeService.setProperty(n1, typeCategoriesProp, values); + nodeService.setProperty(n1, typeNoderefsProp, values); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertyMixedList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + ArrayList values = new ArrayList(); + values.add(cat); + values.add(rootNodeRef); + values.add(invalidNodeRef); + + nodeService.setProperty(n1, typeCategoriesProp, values); + nodeService.setProperty(n1, typeNoderefsProp, values); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(2, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(2, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertiesNull() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + HashMap properties = new HashMap(); + properties.put(typeCategoryProp, null); + properties.put(typeCategoriesProp, null); + properties.put(typeNoderefProp, null); + properties.put(typeNoderefsProp, null); + + nodeService.setProperties(n1, properties); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + } + + public void testSetPropertiesInvalid() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + HashMap properties = new HashMap(); + properties.put(typeCategoryProp, invalidNodeRef); + properties.put(typeCategoriesProp, invalidNodeRef); + properties.put(typeNoderefProp, invalidNodeRef); + properties.put(typeNoderefsProp, invalidNodeRef); + + nodeService.setProperties(n1, properties); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + } + + public void testSetPropertiesNodeRef() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + HashMap properties = new HashMap(); + properties.put(typeCategoryProp, rootNodeRef); + properties.put(typeCategoriesProp, rootNodeRef); + properties.put(typeNoderefProp, rootNodeRef); + properties.put(typeNoderefsProp, rootNodeRef); + + nodeService.setProperties(n1, properties); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNotNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertiesCat() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + HashMap properties = new HashMap(); + properties.put(typeCategoryProp, cat); + properties.put(typeCategoriesProp, cat); + properties.put(typeNoderefProp, cat); + properties.put(typeNoderefsProp, cat); + + nodeService.setProperties(n1, properties); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoryProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefProp)); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoryProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefProp)); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoryProp)); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefProp)); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoryProp)); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefProp)); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + + } + + public void testSetPropertiesEmptyList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + ArrayList values = new ArrayList(); + + HashMap properties = new HashMap(); + properties.put(typeCategoriesProp, values); + properties.put(typeNoderefsProp, values); + + nodeService.setProperties(n1, properties); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertiesNodeRefList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + ArrayList values = new ArrayList(); + values.add(rootNodeRef); + + HashMap properties = new HashMap(); + properties.put(typeCategoriesProp, values); + properties.put(typeNoderefsProp, values); + + nodeService.setProperties(n1, properties); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(0, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(0, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertiesCatList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + ArrayList values = new ArrayList(); + values.add(cat); + + HashMap properties = new HashMap(); + properties.put(typeCategoriesProp, values); + properties.put(typeNoderefsProp, values); + + nodeService.setProperties(n1, properties); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + + public void testSetPropertiesMixedList() + { + NodeRef invalidNodeRef = new NodeRef(rootNodeRef.getStoreRef(), "InvalidNode"); + NodeRef cat = mlAwareNodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}cat"), ContentModel.TYPE_CATEGORY).getChildRef(); + + NodeRef n1 = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName("{namespace}one"), testType).getChildRef(); + + assertNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + + ArrayList values = new ArrayList(); + values.add(cat); + values.add(rootNodeRef); + values.add(invalidNodeRef); + + HashMap properties = new HashMap(); + properties.put(typeCategoriesProp, values); + properties.put(typeNoderefsProp, values); + + nodeService.setProperties(n1, properties); + + assertNotNull(mlAwareNodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(2, ((Collection) mlAwareNodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) mlAwareNodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(2, ((Collection) mlAwareNodeService.getProperties(n1).get(typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperty(n1, typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperty(n1, typeNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperty(n1, typeNoderefsProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeCategoriesProp)); + assertEquals(1, ((Collection) nodeService.getProperties(n1).get(typeCategoriesProp)).size()); + assertNotNull(nodeService.getProperties(n1).get(typeNoderefsProp)); + assertEquals(2, ((Collection) nodeService.getProperties(n1).get(typeNoderefsProp)).size()); + } + +} diff --git a/source/java/org/alfresco/repo/node/NodeRefTestModel.xml b/source/java/org/alfresco/repo/node/NodeRefTestModel.xml new file mode 100644 index 0000000000..64c11102c2 --- /dev/null +++ b/source/java/org/alfresco/repo/node/NodeRefTestModel.xml @@ -0,0 +1,97 @@ + + + Test Model for NodeService tests + Alfresco + 2005-06-05 + 0.1 + + + + + + + + + + + + + + Content + cm:content + false + + + d:category + false + false + + + d:category + false + true + + + d:noderef + false + false + + + d:noderef + false + true + + + + + + + + + Single Category + + + d:category + false + false + + + + + + Multiple Categories + + + d:category + false + true + + + + + + Single Node Ref + + + d:noderef + false + false + + + + + + Mutliple Node Refs + + + d:noderef + false + true + + + + + + \ No newline at end of file diff --git a/source/java/org/alfresco/service/cmr/avm/locking/AVMLock.java b/source/java/org/alfresco/service/cmr/avm/locking/AVMLock.java index 3b650253d5..0784674bd1 100644 --- a/source/java/org/alfresco/service/cmr/avm/locking/AVMLock.java +++ b/source/java/org/alfresco/service/cmr/avm/locking/AVMLock.java @@ -183,4 +183,15 @@ public class AVMLock implements Serializable { return fWebProject; } + + public String toString() + { + StringBuilder buffer = new StringBuilder(); + buffer.append(" (webproject=").append(this.fWebProject); + buffer.append(" store=").append(this.fStore); + buffer.append(" path=").append(this.fPath); + buffer.append(" type=").append(this.fType); + buffer.append(" owners=").append(this.fOwners).append(")"); + return buffer.toString(); + } }