mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-06-30 18:15:39 +00:00
890d3795ce
20440: RM: CapabilitiesTest.testDestroyRecordsCapability (MS SQL Server build) - use non-public nodeService
20441: Include virtual tomcat in installers
20442: Change bitrock builder version to use.
20443: Merged BRANCHES/DEV/V3.3-BUG-FIX to BRANCHES/V3.3: (Fixed tabs and removed 'svn:executable' and 'svn:eol-style')
20384: Merged BRANCHES/DEV/BELARUS/HEAD-2010_04_28 to BRANCHES/DEV/V3.3-BUG-FIX:
20271: ALF-803: Asset Service Improvements
20386: Merged V2.2 to V3.3-BUG-FIX
20385: Merged DEV/BELARUS/V2.2-2010_04_06 to V2.2
20379: V2.2-ALF-1888 AssociationQuery was corrected to filter ...
20387: Version Migrator (ALF-1000) - approx x3 boost (policies ignore version2 store)
20388: Merged BRANCHES/DEV/BELARUS/HEAD-2010_04_28 to BRANCHES/DEV/V3.3-BUG-FIX:
20372: ALF-897: It is impossible to create content when default value selected in ContentHeadlineBackground field for intranet_rssi_landing_template web-form (also fixes ALF-2798 & ALF-791)
20389: Merged BRANCHES/DEV/BELARUS/HEAD-2010_04_28 to BRANCHES/DEV/V3.3-BUG-FIX:
20374: ALF-2723: WCM - Http 500 creating content via webform
20394: Fix for ALF-2257 - It's impossible to find and add group at Records Manage Permissions page
20396: Fixed ALF-2956 "XSS attack is made when a rule is being deleted"
20397: Fix for ALF-922: Mysql does not support unique keys that contain nulls as one would expect
20402: ALF-2186 : Rules not being fired on datalist items - because it's a zero byte file?
20404: Fixed ALF-2109 "Rule doesn't apply to the files in sub-folders when 'Run rule for this folder and its subfolders' action was performed"
20406: Fix for ALF-2985 - Share document library throws error if document modifier or creator is deleted from Alfresco
20409: Improved FormServiceImplTest, added more content related tests and some edge case tests using the FDK model (this test needs to be manually enabled though as the FDK model is not available by default)
20414: Merged DEV/BELARUS/HEAD-2010_04_28 to DEV/V3.3-BUG-FIX
20401: ALF-2616: Serious Web Form layout performance issues on IE8. This fix contains:
20427: Merged DEV/BELARUS/HEAD-2010_04_28 to DEV/V3.3-BUG-FIX
20042: ALF-1523: Failed Kerberos SSO auth doesn't fail through, simply returns a blank page
20323: ALF-1523: Failed Kerberos SSO auth doesn't fail through, simply returns a blank page
20428: Merged DEV/BELARUS/HEAD-2010_04_28 to DEV/V3.3-BUG-FIX
20417: ALF-736: WebDAV Folder Renaming fails on Mac but works on Windows.
20430: Fix for ALF-2313 - Accessing a Doclib folder in Share which has a link to a deleted node fails
20431: Version Migrator (ALF-1000) - migrate 1st batch independently
20432: Fix for ALF-2327 - Can not have more than one Transfer Step in a disposal schedule
20438: ALF-479: Merged DEV/BELARUS/V3.2-2010_01_11 to DEV/V3.3-BUG-FIX
18448: ETHREEOH-4044: External Authentication Subsystem does not perform user mapping for WebDAV requests
20444: Fix for ConcurrentModificationException in file server quota manager. ALF-2970.
20445: Merged HEAD to BRANCHES/V3.3: (RECORD ONLY)
20413: Added clean of quickr project
20446: Changed version to 3.3.1dev
20447: Merged V3.3-BUG-FIX to V3.3
20294: Fixes: ALF-1020 & ALF-1013 for all views except agenda.
20451: Merged V2.2 to V3.3
20450: Merged DEV/BELARUS/V2.2-2010_04_06 to V2.2
20412: ALF-1887: too easy to break alfresco - one can remove the guest user and recreate it but then access to RSS is broken
- PersonServiceImpl.beforeDeleteNode prohibits attempts to delete a guest user.
20452: Fix for transaction error from NFS server file expiry thread. ALF-3016.
20458: ALF-2729 - rationalise (and deprecate) VersionLabelComparator
20460: Fix for ALF-2430
- AVM nodes are not checked for exclusion - the default ACLEntryVoter will always vote for AVM
- avoids embedded AVM permission checks for getType/getAspect and anything else that may be added
- seems AVM read is not checked upon "lookup" for the last node in the PATH (getType should have failed too)
20466: Merged V2.2 to V3.3
20243: (RECORD ONLY) ALF-2814: Merged V3.2 to V2.2
17891: Merged DEV_TEMPORARY to V3.2
17873: ETHREEOH-3810: WCM - Recursion detector erroring
20467: Merged V3.1 to V3.3 (RECORD ONLY)
20276: Incremented version label
20275: ALF-2845: Merged V3.2 to V3.1
17768: Merged DEV/BELARUS/V3.2-2009_11_24 to V3.2
17758: ETHREEOH-3757: Oracle upgrade issue: failed "inviteEmailTemplate" patch - also causes subsequent patches to not be applied
19573: Merged V3.2 to V3.1
19539: Merged HEAD to V3.2
19538: Build fix - fix build speed
20468: Merged PATCHES/V3.2.r to V3.3 (RECORD ONLY)
20357: Merged PATCHES/V3.2.0 to PATCHES/V3.2.r
20349: Merged V3.3 to PATCHES/V3.2.0
20346: ALF-2839: Node pre-loading generates needless resultset rows
- Added missing Criteria.list() call
20339: Incremented version label
20338: Merged PATCHES/V3.2.0 to PATCHES/V3.2.r
20280: Fixed ALF-2839: Node pre-loading generates needless resultset rows
- Split Criteria query to retrieve properties and aspects separately
20272: Backports to help fix ALF-2839: Node pre-loading generates needless resultset rows
Merged BRANCHES/V3.2 to PATCHES/V3.2.0:
18490: Added cache for alf_content_data
Merged BRANCHES/DEV/V3.3-BUG-FIX to PATCHES/V3.2.0:
20231: Fixed ALF-2784: Degradation of performance between 3.1.1 and 3.2x (observed in JSF)
20266: Test reproduction of ALF-2839 failure: Node pre-loading generates needless resultset rows
20469: Merged PATCHES/V3.1.2 to V3.3 (RECORD ONLY)
20393: Eclipse classpath fix to avoid problems in JBoss
20309: ALF-2777: PrimaryChildAssocCopyBehaviour from MOB-388 corrupts cm:name attributes of copied child nodes
- Folded example behaviours from previous AMP into repository
- Fixed PrimaryChildAssocCopyBehaviour to back-up and set the cm:name property on copied children
20470: Merged PATCHES/V3.2.0 to V3.3 (RECORD ONLY)
20465: Incremented version label
20464: ALF-3060: Merged V3.2 to PATCHES/V3.2.0
19920: Merged HEAD to BRANCHES/V3.2:
19918: Fix ALF-2499 (Deleting a web project also deletes similarly named web projects - Potential Data Loss)
20448: Merged DEV/V3.3-BUG-FIX to PATCHES/V3.2.0
20414: Merged DEV/BELARUS/HEAD-2010_04_28 to DEV/V3.3-BUG-FIX
20401: ALF-2616: Serious Web Form layout performance issues on IE8. This fix contains:
a) X-UA-Compatible head tag with IE=EmulateIE7 value
b) alfresco.ieVersion and alfresco.ieEngine in common.js
c) recurseOnChildren in _updateDisplay
d) Some performance modifications in xforms.js
20350: Increment version label
20349: Merged V3.3 to PATCHES/V3.2.0
20346: ALF-2839: Node pre-loading generates needless resultset rows
- Added missing Criteria.list() call
20471: Fix for offline sync losing metadata properties, due to rename/delete of original file. ALF-575.
20478: Merged HEAD to BRANCHES/V3.3: (RECORD ONLY)
20477: Fix ALF-3086: CMIS checkin of a non-versionable document should make it versionable
20479: ALF-2110: Make it possible to determine which person properties are synced via LDAP and hence immutable
- Added Set<QName> UserRegistrySynchronizer.getPersonMappedProperties(String username)
- UI/Services Fix to follow
20481: Latest SpringSurf libs:
- Fix for ALF-1518 - Added support for HTTP and HTTPS proxies for Surf application remote api calls - via the standard JVM cmd line properties such as -Dhttp.proxyHost=...
20484: ALF-2886: LDAP sync defaults display names incorrectly and can't cope with DNs containing escaped trailing whitespace.
- Had to work around a JDK bug in LDAP RDN parsing
20486: Added case sensitive flag to the file state cache. Part of ALF-570.
20487: Fix for copy/rename of folders causing file exists errors in some cases. ALF-570.
20488: Fix ALF-680: Previously valid content models now fail with CMISAbstractDictionaryService$DictionaryRegistry exception
20489: Uploaded correct version of spring source jars and reunited them with 3rd-party/.classpath
20490: Fix for cannot delete folders via CIFS from Mac OSX, due to desktop actions. ALF-2553.
20491: Merged DEV/TEMPORARY to V3.3 (With corrections)
20485: ALF-2290: a HTTP GET request of a document redirects to the Home Location when using NTLM SSO
The logic related to ADB-61 in NTLMAuthenticationFilter clears previous location and redirects request to default home location. NTLMAuthenticationFilter was changed to process GET requests to documents correctly. Now, fix to ADB-61 processes only “/faces” requests and GET requests to documents are processed correctly.
The same fix was made to KerberosAuthenticationFilter
20492: Fix ALF-680: Previously valid content models now fail with CMISAbstractDictionaryService$DictionaryRegistry exception
- missing remove directory
20493: Fix ALF-2837: ClassCastException in getProperties()
20498: Fix for ALF-2818: Failure to close index writer under certain conditions.
- fix for index writer to close indexes when stopped by exceptions during FTS
- fix FTS job to handle exceptions better
- debug for FTS background operations
20499: ALF-3094: In ticket authenticate method in AuthenticationHelper, invalidate the current session if its cached ticket doesn't match
20500: Fix for ALF-2858 "Zero KB sized bin files will be created in the contentstore when new sites are created" (RECORD ONLY)
20503: AVMTestSuite: minor fixes to cleanup ctx usage (avoid re-loading)
20505: Merged BRANCHES/V2.2 to BRANCHES/V3.3 (record-only)
13859: (record-only) Removed dev from version label
14003: (record-only) Updated version to 2.2.5dev
14566: (record-only) ETWOTWO-1239 - remove workflow interpreter/console bootstrap
14572: (record-only) ETWOTWO-1239 - fix PersonTest to fix JBPMEngineTest (part-sourced from r13247)
14776: (record-only) Merged V3.1 to V2.2
14748: ETHREEOH-2225 - WCM upgrade (performance improvements for MySQL)
20506: NFS ReadDir/ReadDirPlus skips some folder entries. JLAN-98.
20507: Fixed issue with folder search resume id being reset to the wrong value during NFS folder search. Part of JLAN-98.
20508: Merged BRANCHES/V3.2 to BRANCHES/V3.3:
18319: Merged BRANCHES/DEV/BELARUS/V3.2-2010_01_11 to V3.2
18273: ETHREEOH-3834: WCM: An extral .xml.html file is created when editing newly created content
19182: Merged V3.1 to V3.2
18423: ETHREEOH-3850 - Content Manager unable to edit content items if there is a lock on a generated rendition
18432: (RECORD ONLY) Added FTP data port range configuration via <dataPorts>n:n</dataPorts> config value. ETHREEOH-4103.
18451: (RECORD ONLY) Fixed incorrect FTP debug level name.
18577: (RECORD ONLY) Fix for ETHREEOH-4117, based on CHK-11154
18792: Fix ETHREEOH-2729: Import of property with @ symbol in name fails with "start tag unexpected character @ "
19570: ALF-192 / ALF-1750: System Error if user trying submit web content based on web form which was deleted
19583: Merged DEV/BELARUS/V3.2-2010_03_17 to V3.2
19545: ALF-1954: Regression: same item can be submitted multiple times to workflow
19725: AVMStoreDescriptor - fix minor typo (for debugging)
19917: (RECORD ONLY) Merged HEAD to BRANCHES/V3.2:
19880: Fix ALF-898 - WCM: Deleting a file leads to error (only if RM/DOD installed)
19920: (RECORD ONLY) Merged HEAD to BRANCHES/V3.2:
19918: Fix ALF-2499 (Deleting a web project also deletes similarly named web projects - Potential Data Loss)
20509: Merged BRANCHES/V3.2 to BRANCHES/V3.3 (RECORD ONLY):
19825: (RECORD ONLY) Merged PATCHES/V3.2.r to BRANCHES/V3.2:
19804: Merged PATCHES/V3.2.0 to PATCHES/V3.2.r
Merged HEAD to V3.2.0
...
20510: Merged BRANCHES/V3.1 to BRANCHES/V3.3 (RECORD ONLY)
17482: (RECORD ONLY) Merged V3.2 to V3.1
17478: Fix ETHREEOH-3340 - WCM - Revert to snapshot failure (fix AVM getListing -> AVMSync compare -> WCM revertSnapshot)
18783: (RECORD ONLY) MT: ensure group (EMAIL_CONTRIBUTORS) bootstraps tenant admin user (when creating tenant)
20513: Added port change example for remote Alfresco server to share-config-custom.xml.sample
20518: ALF-657 Created tests to check that the 'runas' functionality works in the AlfrescoJavaScript action handler. Also modified the handler to run as the System user if no Authentication is currently set, as may occur if the action handler is being executed asynchronously.
20519: ALF-657 Created tests to check that the 'runas' functionality works in the AlfrescoJavaScript action handler. Also modified the handler to run as the System user if no Authentication is currently set, as may occur if the action handler is being executed asynchronously.
20520: Removed dev version.label
20522: ALF-3129: Map cm:organization property in LDAP as well as cm:organizationId, since cm:organization is what shows up in JSF and Share. Needed by ALF-2110.
20523: First part of fix for ALF-2110:
- Appropriate Person and webframework metadata APIs now return information on immutability of Person properties (as some properties are immutable when synced to LDAP etc.)
- Share client now correctly disables profile fields in User Profile and Admin User Console as appropriate based on individual user property mutability
- Change Password button now correctly enabled/disabled based on account mutability
20524: VersionMigrator - option to run as scheduled job (ALF-1000)
20525: Fix for various IE6 CSS issues:
ALF-3047 - It's impossible to destinate any action with data list item (IE6 specific)
ALF-3049 - Incorrect layout of Manage aspects page
ALF-3050 - Incorrect layout of Assign Workflow form
20526: Fix for ALF-2915 - Select > None feature for Data Lists not working across multiple pages in IE
Closed ALF-2846 - DataList UI not fully I18Ned [Old prototype code]
20527: Fix for ALF-3082 - There is no Edit Offline action at Details page in Share site
20528: Fix various script errors due to typo:
ALF-3088 - Script error occurs on creating duplicated record seria
ALF-3012 - Incorrect behaviour on creating duplicating folders
ALF-3004 - Script error when submitting an item with long data in Prioprity field
20529: Fix for ALF-3006 - Selected Items > Copy to... and Move to actions not working in Document Library
20530: Dynamic Models - fix test(s)
- fix concurrency test for Oracle build (retry if txn lock cannot be acquired)
- when getting deployed models, skip if invalid (eg. cannot be parsed)
20536: Remove @Override (ALF-657)
20537: Activities - (minor) fix NPE for Oracle build/test
20543: Final part of ALF-2110 - Appropriate person properties disabled for editing in Explorer Client if external mapped sync such as LDAP is used.
Fixed issue with Change Password option being disabled incorrectly.
20544: Follow-up fix to r20528
20546: Fix for ALF-3151 - Freemarker causes NPE while deploying 3.3 enterprise onto WebSphere 7.0.0.7
- NOTE: will need to submit patch to freemarker.org
20552: Merged BRANCHES/V3.2 to BRANCHES/V3.3 (RECORD ONLY)
20551: (RECORD ONLY) Merged BRANCHES/V3.3 to BRANCHES/V3.2:
20090: Dynamic models: minor improvements to DictionaryModelType
20553: Fix for escalated issue ALF-2856: Space returns to browse view after completing Add Content dialog; need a way to return to custom view (applied patch provided by customer).
20554: Improvement to model delete validation (investigating intermittent failure of RepoAdminServiceImplTest.testSimpleDynamicModelViaNodeService)
20558: Merged DEV/BELARUS/V3.3-2010_06_08 to V3.3
20550: ALF-922: Mysql does not support unique keys that contain nulls as one would expect ...... duplicates in the alf_access_control_entry table
20562: ALF-3177 - security fix.
20563: Merged BRANCHES/V3.2 to BRANCHES/V3.3:
19412: Fix for ALF-865 "WCM / Cluster: unexpected error when concurrently submitting content"
ALF-862 "WCM submit execution will require locking in a clustered WCM authoring env"
20564: Merged BRANCHES/V3.1 to BRANCHES/V3.3:
20542: Fixed ALF-3152: ImporterComponent transaction retry settings can cause IllegalArgumentException
20568: Follow-up on fix ALF-3152. Fix jobLockService's retryWaitIncrementMs
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@20572 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
1728 lines
77 KiB
Java
1728 lines
77 KiB
Java
/*
|
|
* Copyright (C) 2005-2010 Alfresco Software Limited.
|
|
*
|
|
* This file is part of Alfresco
|
|
*
|
|
* Alfresco is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package org.alfresco.repo.rule;
|
|
|
|
import java.io.File;
|
|
import java.io.Serializable;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import javax.transaction.UserTransaction;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
import org.alfresco.model.ApplicationModel;
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.repo.action.ActionServiceImplTest;
|
|
import org.alfresco.repo.action.ActionServiceImplTest.AsyncTest;
|
|
import org.alfresco.repo.action.evaluator.ComparePropertyValueEvaluator;
|
|
import org.alfresco.repo.action.evaluator.InCategoryEvaluator;
|
|
import org.alfresco.repo.action.evaluator.NoConditionEvaluator;
|
|
import org.alfresco.repo.action.executer.AddFeaturesActionExecuter;
|
|
import org.alfresco.repo.action.executer.CheckInActionExecuter;
|
|
import org.alfresco.repo.action.executer.CheckOutActionExecuter;
|
|
import org.alfresco.repo.action.executer.CopyActionExecuter;
|
|
import org.alfresco.repo.action.executer.ImageTransformActionExecuter;
|
|
import org.alfresco.repo.action.executer.LinkCategoryActionExecuter;
|
|
import org.alfresco.repo.action.executer.MailActionExecuter;
|
|
import org.alfresco.repo.action.executer.MoveActionExecuter;
|
|
import org.alfresco.repo.action.executer.SimpleWorkflowActionExecuter;
|
|
import org.alfresco.repo.action.executer.TransformActionExecuter;
|
|
import org.alfresco.repo.content.MimetypeMap;
|
|
import org.alfresco.repo.content.transform.AbstractContentTransformerTest;
|
|
import org.alfresco.repo.content.transform.ContentTransformer;
|
|
import org.alfresco.repo.content.transform.ContentTransformerRegistry;
|
|
import org.alfresco.repo.dictionary.DictionaryDAO;
|
|
import org.alfresco.repo.dictionary.IndexTokenisationMode;
|
|
import org.alfresco.repo.dictionary.M2Aspect;
|
|
import org.alfresco.repo.dictionary.M2Model;
|
|
import org.alfresco.repo.dictionary.M2Property;
|
|
import org.alfresco.repo.security.authentication.AuthenticationComponent;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil;
|
|
import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
|
|
import org.alfresco.service.ServiceRegistry;
|
|
import org.alfresco.service.cmr.action.Action;
|
|
import org.alfresco.service.cmr.action.ActionCondition;
|
|
import org.alfresco.service.cmr.action.ActionService;
|
|
import org.alfresco.service.cmr.coci.CheckOutCheckInService;
|
|
import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
|
|
import org.alfresco.service.cmr.dictionary.PropertyDefinition;
|
|
import org.alfresco.service.cmr.lock.LockService;
|
|
import org.alfresco.service.cmr.lock.LockStatus;
|
|
import org.alfresco.service.cmr.model.FileFolderService;
|
|
import org.alfresco.service.cmr.repository.ChildAssociationRef;
|
|
import org.alfresco.service.cmr.repository.ContentData;
|
|
import org.alfresco.service.cmr.repository.ContentService;
|
|
import org.alfresco.service.cmr.repository.ContentWriter;
|
|
import org.alfresco.service.cmr.repository.CopyService;
|
|
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.cmr.repository.TransformationOptions;
|
|
import org.alfresco.service.cmr.rule.Rule;
|
|
import org.alfresco.service.cmr.rule.RuleService;
|
|
import org.alfresco.service.cmr.rule.RuleServiceException;
|
|
import org.alfresco.service.cmr.rule.RuleType;
|
|
import org.alfresco.service.namespace.NamespaceService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.service.namespace.RegexQNamePattern;
|
|
import org.alfresco.service.transaction.TransactionService;
|
|
import org.alfresco.util.ApplicationContextHelper;
|
|
import org.springframework.context.ApplicationContext;
|
|
import org.springframework.util.StopWatch;
|
|
|
|
/**
|
|
* @author Roy Wetherall
|
|
*/
|
|
public class RuleServiceCoverageTest extends TestCase
|
|
{
|
|
/**
|
|
* Application context used during the test
|
|
*/
|
|
static ApplicationContext applicationContext = ApplicationContextHelper.getApplicationContext();
|
|
|
|
/**
|
|
* Services used during the tests
|
|
*/
|
|
private TransactionService transactionService;
|
|
private RuleService ruleService;
|
|
private NodeService nodeService;
|
|
private StoreRef testStoreRef;
|
|
private NodeRef rootNodeRef;
|
|
private NodeRef nodeRef;
|
|
private CheckOutCheckInService cociService;
|
|
private LockService lockService;
|
|
private ContentService contentService;
|
|
private ServiceRegistry serviceRegistry;
|
|
private DictionaryDAO dictionaryDAO;
|
|
private ActionService actionService;
|
|
private ContentTransformerRegistry transformerRegistry;
|
|
private CopyService copyService;
|
|
private AuthenticationComponent authenticationComponent;
|
|
private FileFolderService fileFolderService;
|
|
|
|
/**
|
|
* Category related values
|
|
*/
|
|
private static final String TEST_NAMESPACE = "http://www.alfresco.org/test/rulesystemtest";
|
|
private static final QName CAT_PROP_QNAME = QName.createQName(TEST_NAMESPACE, "region");
|
|
private QName regionCategorisationQName;
|
|
private NodeRef catContainer;
|
|
private NodeRef catRoot;
|
|
private NodeRef catRBase;
|
|
private NodeRef catROne;
|
|
private NodeRef catRTwo;
|
|
@SuppressWarnings("unused")
|
|
private NodeRef catRThree;
|
|
|
|
/**
|
|
* Standard content text
|
|
*/
|
|
private static final String STANDARD_TEXT_CONTENT = "standardTextContent";
|
|
|
|
/**
|
|
* Setup method
|
|
*/
|
|
@Override
|
|
protected void setUp() throws Exception
|
|
{
|
|
// Get the required services
|
|
this.serviceRegistry = (ServiceRegistry)applicationContext.getBean(ServiceRegistry.SERVICE_REGISTRY);
|
|
this.nodeService = serviceRegistry.getNodeService();
|
|
this.ruleService = serviceRegistry.getRuleService();
|
|
this.cociService = serviceRegistry.getCheckOutCheckInService();
|
|
this.lockService = serviceRegistry.getLockService();
|
|
this.copyService = serviceRegistry.getCopyService();
|
|
this.contentService = serviceRegistry.getContentService();
|
|
this.dictionaryDAO = (DictionaryDAO)applicationContext.getBean("dictionaryDAO");
|
|
this.actionService = serviceRegistry.getActionService();
|
|
this.transactionService = serviceRegistry.getTransactionService();
|
|
this.transformerRegistry = (ContentTransformerRegistry)applicationContext.getBean("contentTransformerRegistry");
|
|
this.authenticationComponent = (AuthenticationComponent)applicationContext.getBean("authenticationComponent");
|
|
this.fileFolderService = serviceRegistry.getFileFolderService();
|
|
|
|
//authenticationComponent.setCurrentUser(authenticationComponent.getSystemUserName());
|
|
//authenticationComponent.setSystemUserAsCurrentUser();
|
|
RetryingTransactionCallback<Object> setUserCallback = new RetryingTransactionCallback<Object>()
|
|
{
|
|
public Object execute() throws Exception
|
|
{
|
|
authenticationComponent.setCurrentUser(AuthenticationUtil.getAdminUserName());
|
|
return null;
|
|
}
|
|
};
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(setUserCallback);
|
|
|
|
this.testStoreRef = this.nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, "Test_" + System.currentTimeMillis());
|
|
this.rootNodeRef = this.nodeService.getRootNode(this.testStoreRef);
|
|
|
|
// Create the node used for tests
|
|
this.nodeRef = this.nodeService.createNode(
|
|
this.rootNodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
ContentModel.TYPE_CONTAINER).getChildRef();
|
|
}
|
|
|
|
private Rule createRule(
|
|
String ruleTypeName,
|
|
String actionName,
|
|
Map<String, Serializable> actionParams,
|
|
String conditionName,
|
|
Map<String, Serializable> conditionParams)
|
|
{
|
|
Rule rule = new Rule();
|
|
rule.setRuleType(ruleTypeName);
|
|
|
|
Action action = this.actionService.createAction(actionName, actionParams);
|
|
ActionCondition condition = this.actionService.createActionCondition(conditionName, conditionParams);
|
|
action.addActionCondition(condition);
|
|
rule.setAction(action);
|
|
|
|
return rule;
|
|
}
|
|
|
|
/**
|
|
* Create the categories used in the tests
|
|
*/
|
|
private void createTestCategories()
|
|
{
|
|
// Create the test model
|
|
M2Model model = M2Model.createModel("test:rulecategory");
|
|
model.createNamespace(TEST_NAMESPACE, "test");
|
|
model.createImport(NamespaceService.DICTIONARY_MODEL_1_0_URI, "d");
|
|
model.createImport(NamespaceService.CONTENT_MODEL_1_0_URI, NamespaceService.CONTENT_MODEL_PREFIX);
|
|
|
|
// Create the region category
|
|
regionCategorisationQName = QName.createQName(TEST_NAMESPACE, "region");
|
|
M2Aspect generalCategorisation = model.createAspect("test:" + regionCategorisationQName.getLocalName());
|
|
generalCategorisation.setParentName("cm:" + ContentModel.ASPECT_CLASSIFIABLE.getLocalName());
|
|
M2Property genCatProp = generalCategorisation.createProperty("test:region");
|
|
genCatProp.setIndexed(true);
|
|
genCatProp.setIndexedAtomically(true);
|
|
genCatProp.setMandatory(true);
|
|
genCatProp.setMultiValued(true);
|
|
genCatProp.setStoredInIndex(true);
|
|
genCatProp.setIndexTokenisationMode(IndexTokenisationMode.TRUE);
|
|
genCatProp.setType("d:" + DataTypeDefinition.CATEGORY.getLocalName());
|
|
|
|
// Save the mode
|
|
dictionaryDAO.putModel(model);
|
|
|
|
// Create the category value container and root
|
|
catContainer = nodeService.createNode(rootNodeRef, ContentModel.ASSOC_CHILDREN, QName.createQName(TEST_NAMESPACE, "categoryContainer"), ContentModel.TYPE_CONTAINER).getChildRef();
|
|
catRoot = nodeService.createNode(catContainer, ContentModel.ASSOC_CHILDREN, QName.createQName(TEST_NAMESPACE, "categoryRoot"), ContentModel.TYPE_CATEGORYROOT).getChildRef();
|
|
|
|
// Create the category values
|
|
catRBase = nodeService.createNode(catRoot, ContentModel.ASSOC_CATEGORIES, QName.createQName(TEST_NAMESPACE, "region"), ContentModel.TYPE_CATEGORY).getChildRef();
|
|
catROne = nodeService.createNode(catRBase, ContentModel.ASSOC_SUBCATEGORIES, QName.createQName(TEST_NAMESPACE, "Europe"), ContentModel.TYPE_CATEGORY).getChildRef();
|
|
catRTwo = nodeService.createNode(catRBase, ContentModel.ASSOC_SUBCATEGORIES, QName.createQName(TEST_NAMESPACE, "RestOfWorld"), ContentModel.TYPE_CATEGORY).getChildRef();
|
|
catRThree = nodeService.createNode(catRTwo, ContentModel.ASSOC_SUBCATEGORIES, QName.createQName(TEST_NAMESPACE, "US"), ContentModel.TYPE_CATEGORY).getChildRef();
|
|
}
|
|
|
|
/**
|
|
* Asynchronous rule tests
|
|
*/
|
|
|
|
/**
|
|
* Check async rule execution
|
|
*/
|
|
public void testAsyncRuleExecution()
|
|
{
|
|
final NodeRef newNodeRef = transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<NodeRef>()
|
|
{
|
|
public NodeRef execute()
|
|
{
|
|
RuleServiceCoverageTest.this.nodeService.addAspect(
|
|
RuleServiceCoverageTest.this.nodeRef,
|
|
ContentModel.ASPECT_LOCKABLE,
|
|
null);
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
rule.setExecuteAsynchronously(true);
|
|
|
|
RuleServiceCoverageTest.this.ruleService.saveRule(RuleServiceCoverageTest.this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef = RuleServiceCoverageTest.this.nodeService.createNode(
|
|
RuleServiceCoverageTest.this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
|
|
return newNodeRef;
|
|
}
|
|
});
|
|
|
|
ActionServiceImplTest.postAsyncActionTest(
|
|
this.transactionService,
|
|
1000,
|
|
100,
|
|
new AsyncTest()
|
|
{
|
|
public String executeTest()
|
|
{
|
|
boolean result = RuleServiceCoverageTest.this.nodeService.hasAspect(
|
|
newNodeRef,
|
|
ContentModel.ASPECT_VERSIONABLE);
|
|
return result ? null : "Expected aspect Versionable";
|
|
};
|
|
});
|
|
}
|
|
|
|
// TODO check compensating action execution
|
|
|
|
/**
|
|
* Standard rule coverage tests
|
|
*/
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition()
|
|
* action: add-features(
|
|
* aspect-name = versionable)
|
|
*/
|
|
public void testAddFeaturesAction()
|
|
{
|
|
this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
Map<String, Serializable> params2 = new HashMap<String, Serializable>(2);
|
|
params2.put(AddFeaturesActionExecuter.PARAM_ASPECT_NAME, ApplicationModel.ASPECT_SIMPLE_WORKFLOW);
|
|
params2.put(ApplicationModel.PROP_APPROVE_STEP.toString(), "approveStep");
|
|
params2.put(ApplicationModel.PROP_APPROVE_MOVE.toString(), false);
|
|
|
|
// Test that rule can be updated and execute correctly
|
|
//rule.removeAllActions();
|
|
Action action2 = this.actionService.createAction(AddFeaturesActionExecuter.NAME, params2);
|
|
rule.setAction(action2);
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef2);
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef2, ApplicationModel.ASPECT_SIMPLE_WORKFLOW));
|
|
assertEquals("approveStep", this.nodeService.getProperty(newNodeRef2, ApplicationModel.PROP_APPROVE_STEP));
|
|
assertEquals(false, this.nodeService.getProperty(newNodeRef2, ApplicationModel.PROP_APPROVE_MOVE));
|
|
|
|
// System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
}
|
|
|
|
public void testModifyNameTriggersInboundRule()
|
|
throws Exception
|
|
{
|
|
//this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
|
|
Map<QName, Serializable> folderProps = new HashMap<QName, Serializable>(1);
|
|
folderProps.put(ContentModel.PROP_NAME, "myTestFolder");
|
|
NodeRef folder = this.nodeService.createNode(
|
|
this.rootNodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
ContentModel.TYPE_FOLDER,
|
|
folderProps).getChildRef();
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(folder, rule);
|
|
|
|
Map<QName, Serializable> contentProps = new HashMap<QName, Serializable>(1);
|
|
contentProps.put(ContentModel.PROP_NAME, "myTestDocument.txt");
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
folder,
|
|
ContentModel.ASSOC_CONTAINS,
|
|
QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "myTestDocument.txt"),
|
|
ContentModel.TYPE_CONTENT,
|
|
contentProps).getChildRef();
|
|
//addContentToNode(newNodeRef);
|
|
nodeService.removeAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Use the file folder to change the name of the node
|
|
this.fileFolderService.rename(newNodeRef, "myNewName.txt");
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
}
|
|
|
|
public void testDisableIndividualRules()
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ApplicationModel.ASPECT_CONFIGURABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
rule.setRuleDisabled(true);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef, ApplicationModel.ASPECT_CONFIGURABLE));
|
|
|
|
Rule rule2 = this.ruleService.getRule(rule.getNodeRef());
|
|
rule2.setRuleDisabled(false);
|
|
this.ruleService.saveRule(this.nodeRef, rule2);
|
|
|
|
// Re-try the test now the rule has been re-enabled
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef2);
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef2, ApplicationModel.ASPECT_CONFIGURABLE));
|
|
|
|
}
|
|
|
|
public void testDisableRule()
|
|
{
|
|
this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
this.ruleService.disableRule(rule);
|
|
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
this.ruleService.enableRule(rule);
|
|
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef2);
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef2, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
}
|
|
|
|
public void testAddFeaturesToAFolder()
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_TEMPLATABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_FOLDER).getChildRef();
|
|
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_TEMPLATABLE));
|
|
|
|
// System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
}
|
|
|
|
public void testCopyFolderToTriggerRules()
|
|
{
|
|
// Create the folders and content
|
|
NodeRef copyToFolder = this.nodeService.createNode(
|
|
this.rootNodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName("{test}copyToFolder"),
|
|
ContentModel.TYPE_FOLDER).getChildRef();
|
|
NodeRef folderToCopy = this.nodeService.createNode(
|
|
this.rootNodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName("{test}folderToCopy"),
|
|
ContentModel.TYPE_FOLDER).getChildRef();
|
|
NodeRef contentToCopy = this.nodeService.createNode(
|
|
folderToCopy,
|
|
ContentModel.ASSOC_CONTAINS,
|
|
QName.createQName("{test}contentToCopy"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(contentToCopy);
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_TEMPLATABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
rule.applyToChildren(true);
|
|
this.ruleService.saveRule(copyToFolder, rule);
|
|
|
|
// Copy the folder in order to try and trigger the rule
|
|
NodeRef copiedFolder = this.copyService.copy(folderToCopy, copyToFolder, ContentModel.ASSOC_CONTAINS, QName.createQName("{test}coppiedFolder"), true);
|
|
assertNotNull(copiedFolder);
|
|
|
|
// Check that the rule has been applied to the copied folder and content
|
|
assertTrue(this.nodeService.hasAspect(copiedFolder, ContentModel.ASPECT_TEMPLATABLE));
|
|
for (ChildAssociationRef childAssoc : this.nodeService.getChildAssocs(copiedFolder))
|
|
{
|
|
assertTrue(this.nodeService.hasAspect(childAssoc.getChildRef(), ContentModel.ASPECT_TEMPLATABLE));
|
|
}
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
}
|
|
|
|
private Map<QName, Serializable> getContentProperties()
|
|
{
|
|
// Map<QName, Serializable> properties = new HashMap<QName, Serializable>(1);
|
|
// properties.put(ContentModel.PROP_CONTENT, CONTENT_DATA_TEXT);
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition
|
|
* action: simple-workflow
|
|
*/
|
|
public void testSimpleWorkflowAction()
|
|
{
|
|
this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(SimpleWorkflowActionExecuter.PARAM_APPROVE_STEP, "approveStep");
|
|
params.put(SimpleWorkflowActionExecuter.PARAM_APPROVE_FOLDER, this.rootNodeRef);
|
|
params.put(SimpleWorkflowActionExecuter.PARAM_APPROVE_MOVE, true);
|
|
params.put(SimpleWorkflowActionExecuter.PARAM_REJECT_STEP, "rejectStep");
|
|
params.put(SimpleWorkflowActionExecuter.PARAM_REJECT_FOLDER, this.rootNodeRef);
|
|
params.put(SimpleWorkflowActionExecuter.PARAM_REJECT_MOVE, false);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
SimpleWorkflowActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef, ApplicationModel.ASPECT_SIMPLE_WORKFLOW));
|
|
assertEquals("approveStep", this.nodeService.getProperty(newNodeRef, ApplicationModel.PROP_APPROVE_STEP));
|
|
assertEquals(this.rootNodeRef, this.nodeService.getProperty(newNodeRef, ApplicationModel.PROP_APPROVE_FOLDER));
|
|
assertTrue(((Boolean)this.nodeService.getProperty(newNodeRef, ApplicationModel.PROP_APPROVE_MOVE)).booleanValue());
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef, ApplicationModel.ASPECT_SIMPLE_WORKFLOW));
|
|
assertEquals("rejectStep", this.nodeService.getProperty(newNodeRef, ApplicationModel.PROP_REJECT_STEP));
|
|
assertEquals(this.rootNodeRef, this.nodeService.getProperty(newNodeRef, ApplicationModel.PROP_REJECT_FOLDER));
|
|
assertFalse(((Boolean)this.nodeService.getProperty(newNodeRef, ApplicationModel.PROP_REJECT_MOVE)).booleanValue());
|
|
|
|
// System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: in-category
|
|
* action: add-feature
|
|
*/
|
|
public void testInCategoryCondition()
|
|
{
|
|
// Create categories used in tests
|
|
createTestCategories();
|
|
|
|
try
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(InCategoryEvaluator.PARAM_CATEGORY_ASPECT, this.regionCategorisationQName);
|
|
params.put(InCategoryEvaluator.PARAM_CATEGORY_VALUE, this.catROne);
|
|
|
|
Map<String, Serializable> params2 = new HashMap<String, Serializable>(1);
|
|
params2.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params2,
|
|
InCategoryEvaluator.NAME,
|
|
params);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
// Check rule does not get fired when a node without the aspect is added
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "noAspect"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef2);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef2, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Check rule gets fired when node contains category value
|
|
RetryingTransactionCallback<NodeRef> callback1 = new RetryingTransactionCallback<NodeRef>()
|
|
{
|
|
public NodeRef execute() throws Throwable
|
|
{
|
|
NodeRef newNodeRef = nodeService.createNode(
|
|
nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "hasAspectAndValue"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
Map<QName, Serializable> catProps = new HashMap<QName, Serializable>();
|
|
catProps.put(CAT_PROP_QNAME, catROne);
|
|
nodeService.addAspect(newNodeRef, regionCategorisationQName, catProps);
|
|
return newNodeRef;
|
|
}
|
|
};
|
|
NodeRef newNodeRef = transactionService.getRetryingTransactionHelper().doInTransaction(callback1);
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Check rule does not get fired when the node has the incorrect category value
|
|
RetryingTransactionCallback<NodeRef> callback3 = new RetryingTransactionCallback<NodeRef>()
|
|
{
|
|
public NodeRef execute() throws Throwable
|
|
{
|
|
NodeRef newNodeRef3 = nodeService.createNode(
|
|
nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "hasAspectAndValue"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef3);
|
|
Map<QName, Serializable> catProps3 = new HashMap<QName, Serializable>();
|
|
catProps3.put(CAT_PROP_QNAME, catRTwo);
|
|
nodeService.addAspect(newNodeRef3, regionCategorisationQName, catProps3);
|
|
return newNodeRef3;
|
|
}
|
|
};
|
|
NodeRef newNodeRef3 = transactionService.getRetryingTransactionHelper().doInTransaction(callback3);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef3, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw new RuntimeException(exception);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition
|
|
* action: link-category
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public void testLinkCategoryAction()
|
|
{
|
|
// Create categories used in tests
|
|
createTestCategories();
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(LinkCategoryActionExecuter.PARAM_CATEGORY_ASPECT, this.regionCategorisationQName);
|
|
params.put(LinkCategoryActionExecuter.PARAM_CATEGORY_VALUE, this.catROne);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
LinkCategoryActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "noAspect"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef2);
|
|
|
|
PropertyDefinition catPropDef = this.dictionaryDAO.getProperty(CAT_PROP_QNAME);
|
|
if (catPropDef == null)
|
|
{
|
|
// Why is it undefined?
|
|
}
|
|
|
|
// Check that the category value has been set
|
|
// It has been declared as a multi-value property, so we expect that here
|
|
Collection<NodeRef> setValue = (Collection<NodeRef>) this.nodeService.getProperty(newNodeRef2, CAT_PROP_QNAME);
|
|
assertNotNull(setValue);
|
|
assertEquals(1, setValue.size());
|
|
assertEquals(this.catROne, setValue.toArray()[0]);
|
|
}
|
|
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition
|
|
* action: mail
|
|
*
|
|
* Note: this test will be removed from the standard list since it is not currently automated
|
|
*/
|
|
public void xtestMailAction()
|
|
{
|
|
this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(MailActionExecuter.PARAM_TO, "alfresco.test@gmail.com");
|
|
params.put(MailActionExecuter.PARAM_SUBJECT, "Unit test");
|
|
params.put(MailActionExecuter.PARAM_TEXT, "This is a test to check that the mail action is working.");
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
MailActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
|
|
// An email should appear in the recipients email
|
|
|
|
// System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition()
|
|
* action: copy()
|
|
*/
|
|
public void testCopyAction()
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(MoveActionExecuter.PARAM_DESTINATION_FOLDER, this.rootNodeRef);
|
|
params.put(MoveActionExecuter.PARAM_ASSOC_TYPE_QNAME, ContentModel.ASSOC_CHILDREN);
|
|
params.put(MoveActionExecuter.PARAM_ASSOC_QNAME, QName.createQName(TEST_NAMESPACE, "copy"));
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
CopyActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "origional"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
|
|
// Check that the created node is still there
|
|
List<ChildAssociationRef> origRefs = this.nodeService.getChildAssocs(
|
|
this.nodeRef,
|
|
RegexQNamePattern.MATCH_ALL,
|
|
QName.createQName(TEST_NAMESPACE, "origional"));
|
|
assertNotNull(origRefs);
|
|
assertEquals(1, origRefs.size());
|
|
NodeRef origNodeRef = origRefs.get(0).getChildRef();
|
|
assertEquals(newNodeRef, origNodeRef);
|
|
|
|
// Check that the created node has been copied
|
|
List<ChildAssociationRef> copyChildAssocRefs = this.nodeService.getChildAssocs(
|
|
this.rootNodeRef,
|
|
RegexQNamePattern.MATCH_ALL, QName.createQName(TEST_NAMESPACE, "copy"));
|
|
assertNotNull(copyChildAssocRefs);
|
|
|
|
// **********************************
|
|
// NOTE: Changed expected result to get build running
|
|
// **********************************
|
|
assertEquals(1, copyChildAssocRefs.size());
|
|
|
|
NodeRef copyNodeRef = copyChildAssocRefs.get(0).getChildRef();
|
|
assertTrue(this.nodeService.hasAspect(copyNodeRef, ContentModel.ASPECT_COPIEDFROM));
|
|
NodeRef source = (NodeRef)this.nodeService.getProperty(copyNodeRef, ContentModel.PROP_COPY_REFERENCE);
|
|
assertEquals(newNodeRef, source);
|
|
|
|
// TODO test deep copy !!
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition()
|
|
* action: transform()
|
|
*/
|
|
public void testTransformAction() throws Throwable
|
|
{
|
|
ContentTransformer transformer = transformerRegistry.getTransformer(
|
|
MimetypeMap.MIMETYPE_EXCEL,
|
|
MimetypeMap.MIMETYPE_TEXT_PLAIN,
|
|
new TransformationOptions());
|
|
if (transformer == null)
|
|
{
|
|
return;
|
|
}
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(TransformActionExecuter.PARAM_MIME_TYPE, MimetypeMap.MIMETYPE_TEXT_PLAIN);
|
|
params.put(TransformActionExecuter.PARAM_DESTINATION_FOLDER, this.rootNodeRef);
|
|
params.put(TransformActionExecuter.PARAM_ASSOC_TYPE_QNAME, ContentModel.ASSOC_CHILDREN);
|
|
params.put(TransformActionExecuter.PARAM_ASSOC_QNAME, QName.createQName(TEST_NAMESPACE, "transformed"));
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
TransformActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
UserTransaction tx = transactionService.getUserTransaction();
|
|
tx.begin();
|
|
|
|
Map<QName, Serializable> props =new HashMap<QName, Serializable>(1);
|
|
props.put(ContentModel.PROP_NAME, "test.xls");
|
|
|
|
// Create the node at the root
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "origional"),
|
|
ContentModel.TYPE_CONTENT,
|
|
props).getChildRef();
|
|
|
|
// Set some content on the origional
|
|
ContentWriter contentWriter = this.contentService.getWriter(newNodeRef, ContentModel.PROP_CONTENT, true);
|
|
contentWriter.setMimetype(MimetypeMap.MIMETYPE_EXCEL);
|
|
File testFile = AbstractContentTransformerTest.loadQuickTestFile("xls");
|
|
contentWriter.putContent(testFile);
|
|
|
|
tx.commit();
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
|
|
AuthenticationComponent authenticationComponent = (AuthenticationComponent)applicationContext.getBean("authenticationComponent");
|
|
authenticationComponent.setCurrentUser(authenticationComponent.getSystemUserName());
|
|
|
|
// Check that the created node is still there
|
|
List<ChildAssociationRef> origRefs = this.nodeService.getChildAssocs(
|
|
this.nodeRef,
|
|
RegexQNamePattern.MATCH_ALL, QName.createQName(TEST_NAMESPACE, "origional"));
|
|
assertNotNull(origRefs);
|
|
assertEquals(1, origRefs.size());
|
|
NodeRef origNodeRef = origRefs.get(0).getChildRef();
|
|
assertEquals(newNodeRef, origNodeRef);
|
|
|
|
// Check that the created node has been copied
|
|
List<ChildAssociationRef> copyChildAssocRefs = this.nodeService.getChildAssocs(
|
|
this.rootNodeRef,
|
|
RegexQNamePattern.MATCH_ALL, QName.createQName(TEST_NAMESPACE, "transformed"));
|
|
assertNotNull(copyChildAssocRefs);
|
|
assertEquals(1, copyChildAssocRefs.size());
|
|
NodeRef copyNodeRef = copyChildAssocRefs.get(0).getChildRef();
|
|
assertTrue(this.nodeService.hasAspect(copyNodeRef, ContentModel.ASPECT_COPIEDFROM));
|
|
NodeRef source = (NodeRef)this.nodeService.getProperty(copyNodeRef, ContentModel.PROP_COPY_REFERENCE);
|
|
assertEquals(newNodeRef, source);
|
|
|
|
// Check the transformed content
|
|
ContentData contentData = (ContentData) nodeService.getProperty(copyNodeRef, ContentModel.PROP_CONTENT);
|
|
assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, contentData.getMimetype());
|
|
}
|
|
|
|
/**
|
|
* Test image transformation
|
|
*
|
|
*/
|
|
public void testImageTransformAction() throws Throwable
|
|
{
|
|
ContentTransformer transformer = transformerRegistry.getTransformer(
|
|
MimetypeMap.MIMETYPE_IMAGE_GIF,
|
|
MimetypeMap.MIMETYPE_IMAGE_JPEG,
|
|
new TransformationOptions());
|
|
if (transformer == null)
|
|
{
|
|
return;
|
|
}
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(ImageTransformActionExecuter.PARAM_DESTINATION_FOLDER, this.rootNodeRef);
|
|
params.put(ImageTransformActionExecuter.PARAM_ASSOC_TYPE_QNAME, ContentModel.ASSOC_CHILDREN);
|
|
params.put(TransformActionExecuter.PARAM_MIME_TYPE, MimetypeMap.MIMETYPE_IMAGE_JPEG);
|
|
params.put(ImageTransformActionExecuter.PARAM_ASSOC_QNAME, QName.createQName(TEST_NAMESPACE, "transformed"));
|
|
params.put(ImageTransformActionExecuter.PARAM_CONVERT_COMMAND, "-negate");
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
ImageTransformActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
UserTransaction tx = transactionService.getUserTransaction();
|
|
tx.begin();
|
|
|
|
Map<QName, Serializable> props =new HashMap<QName, Serializable>(1);
|
|
props.put(ContentModel.PROP_NAME, "test.gif");
|
|
|
|
// Create the node at the root
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "origional"),
|
|
ContentModel.TYPE_CONTENT,
|
|
props).getChildRef();
|
|
|
|
// Set some content on the origional
|
|
ContentWriter contentWriter = this.contentService.getWriter(newNodeRef, ContentModel.PROP_CONTENT, true);
|
|
contentWriter.setMimetype(MimetypeMap.MIMETYPE_IMAGE_GIF);
|
|
File testFile = AbstractContentTransformerTest.loadQuickTestFile("gif");
|
|
contentWriter.putContent(testFile);
|
|
|
|
tx.commit();
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
|
|
// Check that the created node is still there
|
|
List<ChildAssociationRef> origRefs = this.nodeService.getChildAssocs(
|
|
this.nodeRef,
|
|
RegexQNamePattern.MATCH_ALL, QName.createQName(TEST_NAMESPACE, "origional"));
|
|
assertNotNull(origRefs);
|
|
assertEquals(1, origRefs.size());
|
|
NodeRef origNodeRef = origRefs.get(0).getChildRef();
|
|
assertEquals(newNodeRef, origNodeRef);
|
|
|
|
// Check that the created node has been copied
|
|
List<ChildAssociationRef> copyChildAssocRefs = this.nodeService.getChildAssocs(
|
|
this.rootNodeRef,
|
|
RegexQNamePattern.MATCH_ALL, QName.createQName(TEST_NAMESPACE, "transformed"));
|
|
assertNotNull(copyChildAssocRefs);
|
|
assertEquals(1, copyChildAssocRefs.size());
|
|
NodeRef copyNodeRef = copyChildAssocRefs.get(0).getChildRef();
|
|
assertTrue(this.nodeService.hasAspect(copyNodeRef, ContentModel.ASPECT_COPIEDFROM));
|
|
NodeRef source = (NodeRef)this.nodeService.getProperty(copyNodeRef, ContentModel.PROP_COPY_REFERENCE);
|
|
assertEquals(newNodeRef, source);
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition()
|
|
* action: move()
|
|
*/
|
|
public void testMoveAction()
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(MoveActionExecuter.PARAM_DESTINATION_FOLDER, this.rootNodeRef);
|
|
params.put(MoveActionExecuter.PARAM_ASSOC_TYPE_QNAME, ContentModel.ASSOC_CHILDREN);
|
|
params.put(MoveActionExecuter.PARAM_ASSOC_QNAME, QName.createQName(TEST_NAMESPACE, "copy"));
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
MoveActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "origional"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
|
|
// Check that the created node has been moved
|
|
List<ChildAssociationRef> origRefs = this.nodeService.getChildAssocs(
|
|
this.nodeRef,
|
|
RegexQNamePattern.MATCH_ALL, QName.createQName(TEST_NAMESPACE, "origional"));
|
|
assertNotNull(origRefs);
|
|
assertEquals(0, origRefs.size());
|
|
|
|
// Check that the created node is in the new location
|
|
List<ChildAssociationRef> copyChildAssocRefs = this.nodeService.getChildAssocs(
|
|
this.rootNodeRef,
|
|
RegexQNamePattern.MATCH_ALL, QName.createQName(TEST_NAMESPACE, "copy"));
|
|
assertNotNull(copyChildAssocRefs);
|
|
assertEquals(1, copyChildAssocRefs.size());
|
|
NodeRef movedNodeRef = copyChildAssocRefs.get(0).getChildRef();
|
|
assertEquals(newNodeRef, movedNodeRef);
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition()
|
|
* action: checkout()
|
|
*/
|
|
public void testCheckOutAction()
|
|
{
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
CheckOutActionExecuter.NAME,
|
|
null,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
NodeRef newNodeRef = null;
|
|
UserTransaction tx = this.transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
tx.begin();
|
|
|
|
// Create a new node
|
|
newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "checkout"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
|
|
tx.commit();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw new RuntimeException(exception);
|
|
}
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
|
|
// Check that the new node has been checked out
|
|
List<ChildAssociationRef> children = this.nodeService.getChildAssocs(this.nodeRef);
|
|
assertNotNull(children);
|
|
assertEquals(3, children.size()); // includes rule folder
|
|
for (ChildAssociationRef child : children)
|
|
{
|
|
NodeRef childNodeRef = child.getChildRef();
|
|
if (childNodeRef.equals(newNodeRef) == true)
|
|
{
|
|
// check that the node has been locked
|
|
LockStatus lockStatus = this.lockService.getLockStatus(childNodeRef);
|
|
assertEquals(LockStatus.LOCK_OWNER, lockStatus);
|
|
}
|
|
else if (this.nodeService.hasAspect(childNodeRef, ContentModel.ASPECT_WORKING_COPY) == true)
|
|
{
|
|
// assert that it is the working copy that relates to the origional node
|
|
NodeRef copiedFromNodeRef = (NodeRef)this.nodeService.getProperty(childNodeRef, ContentModel.PROP_COPY_REFERENCE);
|
|
assertEquals(newNodeRef, copiedFromNodeRef);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: no-condition()
|
|
* action: checkin()
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public void testCheckInAction()
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(CheckInActionExecuter.PARAM_DESCRIPTION, "The version description.");
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
CheckInActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
List<NodeRef> list = transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<List<NodeRef>>()
|
|
{
|
|
public List<NodeRef> execute()
|
|
{
|
|
// Create a new node and check-it out
|
|
NodeRef newNodeRef = RuleServiceCoverageTest.this.nodeService.createNode(
|
|
RuleServiceCoverageTest.this.rootNodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "origional"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
NodeRef workingCopy = RuleServiceCoverageTest.this.cociService.checkout(newNodeRef);
|
|
|
|
// Move the working copy into the actionable folder
|
|
RuleServiceCoverageTest.this.nodeService.moveNode(
|
|
workingCopy,
|
|
RuleServiceCoverageTest.this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "moved"));
|
|
|
|
List<NodeRef> result = new ArrayList<NodeRef>();
|
|
result.add(newNodeRef);
|
|
result.add(workingCopy);
|
|
return result;
|
|
}
|
|
|
|
});
|
|
|
|
// Check that the working copy has been removed
|
|
assertFalse(this.nodeService.exists(list.get(1)));
|
|
|
|
// Check that the origional is no longer locked
|
|
assertEquals(LockStatus.NO_LOCK, this.lockService.getLockStatus(list.get(0)));
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
}
|
|
|
|
/**
|
|
* Check that the rules can be enabled and disabled
|
|
*/
|
|
public void testRulesDisabled()
|
|
{
|
|
Map<String, Serializable> actionParams = new HashMap<String, Serializable>(1);
|
|
actionParams.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
actionParams,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
this.ruleService.disableRules(this.nodeRef);
|
|
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
this.ruleService.enableRules(this.nodeRef);
|
|
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef2);
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef2, ContentModel.ASPECT_VERSIONABLE));
|
|
}
|
|
|
|
/**
|
|
* Adds content to a given node.
|
|
* <p>
|
|
* Used to trigger rules of type of incomming.
|
|
*
|
|
* @param nodeRef the node reference
|
|
*/
|
|
private void addContentToNode(NodeRef nodeRef)
|
|
{
|
|
ContentWriter contentWriter = this.contentService.getWriter(nodeRef, ContentModel.PROP_CONTENT, true);
|
|
contentWriter.setMimetype(MimetypeMap.MIMETYPE_TEXT_PLAIN);
|
|
contentWriter.setEncoding("UTF-8");
|
|
assertNotNull(contentWriter);
|
|
contentWriter.putContent(STANDARD_TEXT_CONTENT + System.currentTimeMillis());
|
|
}
|
|
|
|
/**
|
|
* Test checkMandatoryProperties method
|
|
*/
|
|
public void testCheckMandatoryProperties()
|
|
{
|
|
Map<String, Serializable> actionParams = new HashMap<String, Serializable>(1);
|
|
actionParams.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Map<String, Serializable> condParams = new HashMap<String, Serializable>(1);
|
|
// should be setting the condition parameter here
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
actionParams,
|
|
ComparePropertyValueEvaluator.NAME,
|
|
condParams);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
try
|
|
{
|
|
// Try and create a node .. should fail since the rule is invalid
|
|
Map<QName, Serializable> props2 = getContentProperties();
|
|
props2.put(ContentModel.PROP_NAME, "bobbins.doc");
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
props2).getChildRef();
|
|
addContentToNode(newNodeRef2);
|
|
fail("An exception should have been thrown since a mandatory parameter was missing from the condition.");
|
|
}
|
|
catch (Throwable ruleServiceException)
|
|
{
|
|
// Success since we where expecting the exception
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: inbound
|
|
* condition: match-text(
|
|
* text = .doc,
|
|
* operation = CONTAINS)
|
|
* action: add-features(
|
|
* aspect-name = versionable)
|
|
*/
|
|
public void testContainsTextCondition()
|
|
{
|
|
Map<String, Serializable> actionParams = new HashMap<String, Serializable>(1);
|
|
actionParams.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
// ActionCondition parameter's
|
|
Map<String, Serializable> condParams = new HashMap<String, Serializable>(1);
|
|
condParams.put(ComparePropertyValueEvaluator.PARAM_VALUE, ".doc");
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
actionParams,
|
|
ComparePropertyValueEvaluator.NAME,
|
|
condParams);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
// Test condition failure
|
|
Map<QName, Serializable> props1 = new HashMap<QName, Serializable>();
|
|
props1.put(ContentModel.PROP_NAME, "bobbins.txt");
|
|
// props1.put(ContentModel.PROP_CONTENT, CONTENT_DATA_TEXT);
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
props1).getChildRef();
|
|
addContentToNode(newNodeRef);
|
|
|
|
//Map<QName, Serializable> map = this.nodeService.getProperties(newNodeRef);
|
|
//String value = (String)this.nodeService.getProperty(newNodeRef, ContentModel.PROP_NAME);
|
|
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Test condition success
|
|
Map<QName, Serializable> props2 = new HashMap<QName, Serializable>();
|
|
props2.put(ContentModel.PROP_NAME, "bobbins.doc");
|
|
//props2.put(ContentModel.PROP_CONTENT, CONTENT_DATA_TEXT);
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
props2).getChildRef();
|
|
addContentToNode(newNodeRef2);
|
|
assertTrue(this.nodeService.hasAspect(
|
|
newNodeRef2,
|
|
ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
try
|
|
{
|
|
// Test name not set
|
|
NodeRef newNodeRef3 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
getContentProperties()).getChildRef();
|
|
addContentToNode(newNodeRef3);
|
|
}
|
|
catch (RuleServiceException exception)
|
|
{
|
|
// Correct since text-match is a mandatory property
|
|
}
|
|
|
|
// Test begins with
|
|
Map<String, Serializable> condParamsBegins = new HashMap<String, Serializable>(1);
|
|
condParamsBegins.put(ComparePropertyValueEvaluator.PARAM_VALUE, "bob*");
|
|
rule.getAction().removeAllActionConditions();
|
|
ActionCondition condition1 = this.actionService.createActionCondition(ComparePropertyValueEvaluator.NAME, condParamsBegins);
|
|
rule.getAction().addActionCondition(condition1);
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
Map<QName, Serializable> propsx = new HashMap<QName, Serializable>();
|
|
propsx.put(ContentModel.PROP_NAME, "mybobbins.doc");
|
|
//propsx.put(ContentModel.PROP_CONTENT, CONTENT_DATA_TEXT);
|
|
NodeRef newNodeRefx = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
propsx).getChildRef();
|
|
addContentToNode(newNodeRefx);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRefx, ContentModel.ASPECT_VERSIONABLE));
|
|
Map<QName, Serializable> propsy = new HashMap<QName, Serializable>();
|
|
propsy.put(ContentModel.PROP_NAME, "bobbins.doc");
|
|
//propsy.put(ContentModel.PROP_CONTENT, CONTENT_DATA_TEXT);
|
|
NodeRef newNodeRefy = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
propsy).getChildRef();
|
|
addContentToNode(newNodeRefy);
|
|
assertTrue(this.nodeService.hasAspect(
|
|
newNodeRefy,
|
|
ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Test ends with
|
|
Map<String, Serializable> condParamsEnds = new HashMap<String, Serializable>(1);
|
|
condParamsEnds.put(ComparePropertyValueEvaluator.PARAM_VALUE, "*s.doc");
|
|
rule.getAction().removeAllActionConditions();
|
|
ActionCondition condition2 = this.actionService.createActionCondition(ComparePropertyValueEvaluator.NAME, condParamsEnds);
|
|
rule.getAction().addActionCondition(condition2);
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
Map<QName, Serializable> propsa = new HashMap<QName, Serializable>();
|
|
propsa.put(ContentModel.PROP_NAME, "bobbins.document");
|
|
// propsa.put(ContentModel.PROP_CONTENT, CONTENT_DATA_TEXT);
|
|
NodeRef newNodeRefa = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
propsa).getChildRef();
|
|
addContentToNode(newNodeRefa);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRefa, ContentModel.ASPECT_VERSIONABLE));
|
|
Map<QName, Serializable> propsb = new HashMap<QName, Serializable>();
|
|
propsb.put(ContentModel.PROP_NAME, "bobbins.doc");
|
|
//propsb.put(ContentModel.PROP_CONTENT, CONTENT_DATA_TEXT);
|
|
NodeRef newNodeRefb = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT,
|
|
propsb).getChildRef();
|
|
addContentToNode(newNodeRefb);
|
|
assertTrue(this.nodeService.hasAspect(
|
|
newNodeRefb,
|
|
ContentModel.ASPECT_VERSIONABLE));
|
|
}
|
|
|
|
public void testInboundRuleType()
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
// Create a non-content node
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTAINER).getChildRef();
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Create a content node
|
|
NodeRef contentNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT).getChildRef();
|
|
assertTrue(this.nodeService.hasAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
addContentToNode(contentNodeRef);
|
|
assertTrue(this.nodeService.hasAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Create a node to be moved
|
|
NodeRef moveNode = this.nodeService.createNode(
|
|
newNodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT).getChildRef();
|
|
addContentToNode(moveNode);
|
|
assertFalse(this.nodeService.hasAspect(moveNode, ContentModel.ASPECT_VERSIONABLE));
|
|
this.nodeService.moveNode(
|
|
moveNode,
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"));
|
|
assertTrue(this.nodeService.hasAspect(moveNode, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Enusre the rule type does not get fired when the node is updated
|
|
this.nodeService.removeAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE);
|
|
assertFalse(this.nodeService.hasAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
this.nodeService.setProperty(contentNodeRef, ContentModel.PROP_NAME, "name.txt");
|
|
assertFalse(this.nodeService.hasAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
addContentToNode(contentNodeRef);
|
|
assertFalse(this.nodeService.hasAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
}
|
|
|
|
public void testUpdateRuleType()
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
Rule rule = createRule(
|
|
RuleType.UPDATE,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
// Create a non-content node
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_FOLDER).getChildRef();
|
|
this.nodeService.removeAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE);
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Update the non-content node
|
|
this.nodeService.setProperty(newNodeRef, ContentModel.PROP_NAME, "testName");
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Create a content node
|
|
NodeRef contentNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTENT).getChildRef();
|
|
nodeService.removeAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE);
|
|
assertFalse(this.nodeService.hasAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
addContentToNode(contentNodeRef);
|
|
assertFalse(this.nodeService.hasAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
addContentToNode(contentNodeRef);
|
|
assertTrue(this.nodeService.hasAspect(contentNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Create a non content node, setting a property at the same time
|
|
Map<QName, Serializable> props = new HashMap<QName, Serializable>(1);
|
|
props.put(ContentModel.PROP_NAME, "testName");
|
|
NodeRef nodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_FOLDER,
|
|
props).getChildRef();
|
|
nodeService.removeAspect(nodeRef2, ContentModel.ASPECT_VERSIONABLE);
|
|
assertFalse(this.nodeService.hasAspect(nodeRef2, ContentModel.ASPECT_VERSIONABLE));
|
|
this.nodeService.setProperty(nodeRef2, ContentModel.PROP_NAME, "testName");
|
|
assertFalse(this.nodeService.hasAspect(nodeRef2, ContentModel.ASPECT_VERSIONABLE));
|
|
this.nodeService.setProperty(nodeRef2, ContentModel.PROP_NAME, "testName2");
|
|
assertTrue(this.nodeService.hasAspect(nodeRef2, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Object>()
|
|
{
|
|
public Object execute() throws Exception
|
|
{
|
|
Map<QName, Serializable> props = new HashMap<QName, Serializable>(1);
|
|
props.put(ContentModel.PROP_NAME, "testName");
|
|
NodeRef nodeRef3 = RuleServiceCoverageTest.this.nodeService.createNode(
|
|
RuleServiceCoverageTest.this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_FOLDER,
|
|
props).getChildRef();
|
|
assertFalse(RuleServiceCoverageTest.this.nodeService.hasAspect(nodeRef3, ContentModel.ASPECT_VERSIONABLE));
|
|
RuleServiceCoverageTest.this.nodeService.setProperty(nodeRef3, ContentModel.PROP_NAME, "testName2");
|
|
assertFalse(RuleServiceCoverageTest.this.nodeService.hasAspect(nodeRef3, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Test:
|
|
* rule type: outbound
|
|
* condition: no-condition()
|
|
* action: add-features(
|
|
* aspect-name = versionable)
|
|
*/
|
|
public void testOutboundRuleType()
|
|
{
|
|
this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Rule rule = createRule(
|
|
"outbound",
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
// Create a node
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTAINER).getChildRef();
|
|
assertFalse(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Move the node out of the actionable folder
|
|
this.nodeService.moveNode(
|
|
newNodeRef,
|
|
this.rootNodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"));
|
|
assertTrue(this.nodeService.hasAspect(newNodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
|
|
// Check the deletion of a node
|
|
|
|
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.testStoreRef));
|
|
NodeRef newNodeRef2 = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTAINER).getChildRef();
|
|
this.nodeService.deleteNode(newNodeRef2);
|
|
}
|
|
|
|
/**
|
|
* Performance guideline test
|
|
*
|
|
*/
|
|
public void xtestPerformanceOfRuleExecution()
|
|
{
|
|
try
|
|
{
|
|
StopWatch sw = new StopWatch();
|
|
|
|
// Create actionable nodes
|
|
sw.start("create nodes with no rule executed");
|
|
UserTransaction userTransaction1 = this.transactionService.getUserTransaction();
|
|
userTransaction1.begin();
|
|
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CONTAINS,
|
|
ContentModel.ASSOC_CONTAINS,
|
|
ContentModel.TYPE_CONTAINER).getChildRef();
|
|
assertFalse(this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
}
|
|
|
|
userTransaction1.commit();
|
|
sw.stop();
|
|
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put("aspect-name", ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
AddFeaturesActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
|
|
sw.start("create nodes with one rule run (apply versionable aspect)");
|
|
UserTransaction userTransaction2 = this.transactionService.getUserTransaction();
|
|
userTransaction2.begin();
|
|
|
|
NodeRef[] nodeRefs = new NodeRef[100];
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
NodeRef nodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "children"),
|
|
ContentModel.TYPE_CONTAINER).getChildRef();
|
|
addContentToNode(nodeRef);
|
|
nodeRefs[i] = nodeRef;
|
|
|
|
// Check that the versionable aspect has not yet been applied
|
|
assertFalse(this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_VERSIONABLE));
|
|
}
|
|
|
|
userTransaction2.commit();
|
|
sw.stop();
|
|
|
|
// Check that the versionable aspect has been applied to all the created nodes
|
|
for (NodeRef ref : nodeRefs)
|
|
{
|
|
assertTrue(this.nodeService.hasAspect(ref, ContentModel.ASPECT_VERSIONABLE));
|
|
}
|
|
|
|
System.out.println(sw.prettyPrint());
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw new RuntimeException(exception);
|
|
}
|
|
}
|
|
|
|
public void testAsyncExecutionWithPotentialLoop()
|
|
{
|
|
if (this.transformerRegistry.getTransformer(MimetypeMap.MIMETYPE_EXCEL, MimetypeMap.MIMETYPE_TEXT_PLAIN, new TransformationOptions()) != null)
|
|
{
|
|
try
|
|
{
|
|
Map<String, Serializable> params = new HashMap<String, Serializable>(1);
|
|
params.put(TransformActionExecuter.PARAM_MIME_TYPE, MimetypeMap.MIMETYPE_TEXT_PLAIN);
|
|
params.put(TransformActionExecuter.PARAM_DESTINATION_FOLDER, this.nodeRef);
|
|
params.put(TransformActionExecuter.PARAM_ASSOC_TYPE_QNAME, ContentModel.ASSOC_CONTAINS);
|
|
params.put(TransformActionExecuter.PARAM_ASSOC_QNAME, QName.createQName(TEST_NAMESPACE, "transformed"));
|
|
|
|
Rule rule = createRule(
|
|
RuleType.INBOUND,
|
|
TransformActionExecuter.NAME,
|
|
params,
|
|
NoConditionEvaluator.NAME,
|
|
null);
|
|
rule.setExecuteAsynchronously(true);
|
|
rule.setTitle("Transform document to text");
|
|
|
|
UserTransaction tx0 = transactionService.getUserTransaction();
|
|
tx0.begin();
|
|
this.ruleService.saveRule(this.nodeRef, rule);
|
|
tx0.commit();
|
|
|
|
UserTransaction tx = transactionService.getUserTransaction();
|
|
tx.begin();
|
|
|
|
Map<QName, Serializable> props =new HashMap<QName, Serializable>(1);
|
|
props.put(ContentModel.PROP_NAME, "test.xls");
|
|
|
|
// Create the node at the root
|
|
NodeRef newNodeRef = this.nodeService.createNode(
|
|
this.nodeRef,
|
|
ContentModel.ASSOC_CHILDREN,
|
|
QName.createQName(TEST_NAMESPACE, "origional"),
|
|
ContentModel.TYPE_CONTENT,
|
|
props).getChildRef();
|
|
|
|
// Set some content on the origional
|
|
ContentWriter contentWriter = this.contentService.getWriter(newNodeRef, ContentModel.PROP_CONTENT, true);
|
|
contentWriter.setMimetype(MimetypeMap.MIMETYPE_EXCEL);
|
|
File testFile = AbstractContentTransformerTest.loadQuickTestFile("xls");
|
|
contentWriter.putContent(testFile);
|
|
|
|
tx.commit();
|
|
|
|
// Sleep to ensure work is done b4 execution is canceled
|
|
Thread.sleep(10000);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw new RuntimeException(exception);
|
|
}
|
|
}
|
|
}
|
|
}
|