Java Code Examples for org.springframework.test.context.transaction.TestTransaction#flagForCommit()

@Test
public void commitTxAndStartNewTx() {
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
	assertUsers("Dilbert");
	deleteFromTables("user");
	assertUsers();

	// Commit
	TestTransaction.flagForCommit();
	assertFalse(TestTransaction.isFlaggedForRollback());
	TestTransaction.end();
	assertInTransaction(false);
	assertFalse(TestTransaction.isActive());
	assertUsers();

	executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
	assertUsers("Dogbert");

	TestTransaction.start();
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
}
 

@Test
public void commitTxButDoNotStartNewTx() {
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
	assertUsers("Dilbert");
	deleteFromTables("user");
	assertUsers();

	// Commit
	TestTransaction.flagForCommit();
	assertFalse(TestTransaction.isFlaggedForRollback());
	TestTransaction.end();
	assertFalse(TestTransaction.isActive());
	assertInTransaction(false);
	assertUsers();

	executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
	assertUsers("Dogbert");
}
 

public void xtestAsyncLoadTest()
{
    // TODO this is very weak .. how do we improve this ???
    
    Action action = this.actionService.createAction(AddFeaturesActionExecuter.NAME);
    action.setParameterValue(AddFeaturesActionExecuter.PARAM_ASPECT_NAME, ContentModel.ASPECT_VERSIONABLE);
    action.setExecuteAsynchronously(true);
    
    for (int i = 0; i < 1000; i++)
    {
        this.actionService.executeAction(action, this.nodeRef);
    }

    TestTransaction.flagForCommit();
    TestTransaction.end();
    
    // TODO how do we assess whether the large number of actions stacked cause a problem ??
}
 

@Test
public void commitTxButDoNotStartNewTx() {
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
	assertUsers("Dilbert");
	deleteFromTables("user");
	assertUsers();

	// Commit
	TestTransaction.flagForCommit();
	assertFalse(TestTransaction.isFlaggedForRollback());
	TestTransaction.end();
	assertFalse(TestTransaction.isActive());
	assertInTransaction(false);
	assertUsers();

	executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
	assertUsers("Dogbert");
}
 

@Test
public void commitTxAndStartNewTx() {
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
	assertUsers("Dilbert");
	deleteFromTables("user");
	assertUsers();

	// Commit
	TestTransaction.flagForCommit();
	assertFalse(TestTransaction.isFlaggedForRollback());
	TestTransaction.end();
	assertInTransaction(false);
	assertFalse(TestTransaction.isActive());
	assertUsers();

	executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
	assertUsers("Dogbert");

	TestTransaction.start();
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
}
 

@Test
public void commitTxButDoNotStartNewTx() {
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
	assertUsers("Dilbert");
	deleteFromTables("user");
	assertUsers();

	// Commit
	TestTransaction.flagForCommit();
	assertFalse(TestTransaction.isFlaggedForRollback());
	TestTransaction.end();
	assertFalse(TestTransaction.isActive());
	assertInTransaction(false);
	assertUsers();

	executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
	assertUsers("Dogbert");
}
 

@Test
public void commitTxAndStartNewTx() {
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
	assertUsers("Dilbert");
	deleteFromTables("user");
	assertUsers();

	// Commit
	TestTransaction.flagForCommit();
	assertFalse(TestTransaction.isFlaggedForRollback());
	TestTransaction.end();
	assertInTransaction(false);
	assertFalse(TestTransaction.isActive());
	assertUsers();

	executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
	assertUsers("Dogbert");

	TestTransaction.start();
	assertInTransaction(true);
	assertTrue(TestTransaction.isActive());
}
 

@Test
public void testAutoVersionOff()
{
    // Create a versionable node
    final NodeRef versionableNode = createNewVersionableNode();
    
    this.dbNodeService.setProperty(versionableNode, ContentModel.PROP_AUTO_VERSION, false);

    TestTransaction.flagForCommit();
    TestTransaction.end();

    // The initial version should have been created now
    
    transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Object>()
    {
        public Object execute() throws Exception
        {
            // Add some content 
            ContentWriter contentWriter = contentService.getWriter(versionableNode, ContentModel.PROP_CONTENT, true);
            assertNotNull(contentWriter);
            contentWriter.putContent(UPDATED_CONTENT_1);
            
            return null;
        }
    });
    
    // Now lets have a look and make sure we have the correct number of entries in the version history
    transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Object>()
    {
        public Object execute() throws Exception
        {
            VersionHistory versionHistory = versionService.getVersionHistory(versionableNode);
            assertNotNull(versionHistory);
            assertEquals(1, versionHistory.getAllVersions().size());
            
            return null;
        }
    
    });
}
 

@Test
public void testAddVersionableAspectWithNoVersionType()
{
    // No version-type specified when adding the aspect
    NodeRef nodeRef = createNodeWithVersionType(null);
    TestTransaction.flagForCommit();
    TestTransaction.end();
    assertCorrectVersionLabel(nodeRef, "1.0");
}
 

/**
 * Deletes a child node and then iterates over the children of the parent node,
 * getting the QName.  This caused some issues after we did some optimization
 * using lazy loading of the associations.
 */
public void testLazyLoadIssue() throws Exception
{
    Map<QName, ChildAssociationRef> assocRefs = buildNodeGraph();
    // commit results
    TestTransaction.flagForCommit();
    TestTransaction.end();

    UserTransaction userTransaction = txnService.getUserTransaction();
    
    try
    {
        userTransaction.begin();
        
        ChildAssociationRef n6pn8Ref = assocRefs.get(QName.createQName(BaseNodeServiceTest.NAMESPACE, "n6_p_n8"));
        NodeRef n6Ref = n6pn8Ref.getParentRef();
        NodeRef n8Ref = n6pn8Ref.getChildRef();
        
        // delete n8
        nodeService.deleteNode(n8Ref);
        
        // get the parent children
        List<ChildAssociationRef> assocs = nodeService.getChildAssocs(n6Ref);
        for (ChildAssociationRef assoc : assocs)
        {
            // just checking
        }
        
        userTransaction.commit();
    }
    catch(Exception e)
    {
        try { userTransaction.rollback(); } catch (IllegalStateException ee) {}
        throw e;
    }
}
 

/**
 * See REPO-2519, MNT-17113
 *
 * @throws IOException
 */
@Test
public void testIfNodesExistsAfterCreateThumbnail() throws IOException
{
    // Add the log appender to the root logger
    LogErrorAppender logErrorAppender = new LogErrorAppender();
    Logger.getRootLogger().addAppender(logErrorAppender);

    // create content node for thumbnail node
    NodeRef pdfOrig = createOriginalContent(folder, MimetypeMap.MIMETYPE_PDF);

    QName qname = QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "doclib");
    ThumbnailDefinition details = thumbnailService.getThumbnailRegistry().getThumbnailDefinition(qname.getLocalName());

    TestTransaction.flagForCommit();
    TestTransaction.end();

    // create thumbnail
    transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionHelper.RetryingTransactionCallback<Void>()
    {
        public Void execute() throws Throwable
        {
            // Delete the content node (pdfOrig) before the afterCommit code is executed
            TestNodeDeleterListener testNodeDeleterListener = new TestNodeDeleterListener(pdfOrig);
            // It needs to have a higher priority as the implemented afterCommit. The priority in order are (0,1,2,3,4)
            AlfrescoTransactionSupport.bindListener(testNodeDeleterListener, 1);

            thumbnailService.createThumbnail(pdfOrig, ContentModel.PROP_CONTENT, MimetypeMap.MIMETYPE_IMAGE_JPEG, details.getTransformationOptions(), "doclib");
            return null;
        }
    }, false, true);

    assertEquals("There should be no error anymore", 0, logErrorAppender.getLog().size());
}
 

/**
 * Test for MNT-13055:
 * 
 * We create a folder structure thus:
 * <pre>
 * rootFolder (rule: add an aspect)
 * |
 * +- folderA ("do not inherit rules" + link to rootFolder's rule set) 
 *    |
 *    +- fileA
 *    |
 *    +- folderB
 *       |
 *       +- fileB 
 * </pre>
 * This test case specifies a rule on rootFolder that adds an aspect to all files within.
 * folderA has the ignoreInheritedRules aspect applied, but also links to rootFolder's rule set.
 * <p>
 * We then explicitly execute folderA's rules, including for subfolders. Ultimately, we want to
 * know that fileB did indeed have the ruleset executed on it, and therefore gained the classifiable aspect.
 */
public void testRulesFireOnNonInheritedFolderUsingLinkedRuleSetInstead()
{
    final NodeRef rootFolder = this.nodeService.createNode(
            this.rootNodeRef,
            ContentModel.ASSOC_CHILDREN,
            QName.createQName("{test}rootFolderForTest"),
            ContentModel.TYPE_FOLDER).getChildRef();
    
    final NodeRef folderA = fileFolderService.
            create(rootFolder, "folderA", ContentModel.TYPE_FOLDER).getNodeRef();
    
    // Set folderA to "Don't Inherit Rules".
    nodeService.addAspect(folderA, ASPECT_IGNORE_INHERITED_RULES, Collections.emptyMap());
    
    NodeRef fileA = createFile(folderA, "fileA.txt").getNodeRef();
    
    final NodeRef folderB = fileFolderService.
            create(folderA, "folderB", ContentModel.TYPE_FOLDER).getNodeRef();
    
    NodeRef fileB = createFile(folderB, "fileB.txt").getNodeRef();
    
    // Create a rule on rootFolder
    Rule rule = new Rule();
    rule.setRuleType(RuleType.INBOUND);
    Action action = actionService.createAction(AddFeaturesActionExecuter.NAME);
    action.setParameterValue(AddFeaturesActionExecuter.PARAM_ASPECT_NAME, ContentModel.ASPECT_CLASSIFIABLE);
    rule.setAction(action);
    // It mustn't matter whether this rule "applies to children", since we'll explicitly
    // run it on "the folder and its subfolders".
    rule.applyToChildren(false);
    rule.setExecuteAsynchronously(false);
    ruleService.enableRule(rule);
    ruleService.saveRule(rootFolder, rule);

    // Link to Rule Set of rootFolder to folderA
    Action linkAction = actionService.createAction(LinkRules.NAME);
    linkAction.setParameterValue(LinkRules.PARAM_LINK_FROM_NODE, rootFolder);
    linkAction.setExecuteAsynchronously(false);
    actionService.executeAction(linkAction, folderA);
    
    TestTransaction.flagForCommit();
    TestTransaction.end();

    transactionHelper.doInTransaction(() -> {
        assertFalse(nodeService.hasAspect(folderA, ContentModel.ASPECT_CLASSIFIABLE));
        assertFalse(nodeService.hasAspect(fileA, ContentModel.ASPECT_CLASSIFIABLE));
        assertFalse(nodeService.hasAspect(folderB, ContentModel.ASPECT_CLASSIFIABLE));
        assertFalse(nodeService.hasAspect(fileB, ContentModel.ASPECT_CLASSIFIABLE));
        return null;
    });
    
    
    // rootFolder: "Run rule for this folder and its subfolders".
    transactionHelper.doInTransaction(() -> {
        Map<String, Serializable> actionParams = new HashMap<>();
        actionParams.put(ExecuteAllRulesActionExecuter.PARAM_RUN_ALL_RULES_ON_CHILDREN, true);
        // In Share, when you manually trigger rules on a folder, this parameter (execute-inherited-rules)
        // will be false if the aspect rule:ignoreInheritedRules is present, and true otherwise.
        actionParams.put(ExecuteAllRulesActionExecuter.PARAM_EXECUTE_INHERITED_RULES, false);
        Action rulesAction = actionService.createAction(ExecuteAllRulesActionExecuter.NAME, actionParams);
        executer.execute(rulesAction, folderA);
        return null;
    });

    transactionHelper.doInTransaction(() -> {
        // We're running the rule on folderA, so the folder itself won't be processed.
        assertFalse(nodeService.hasAspect(folderA, ContentModel.ASPECT_CLASSIFIABLE));
        
        // The contents of folderA will all have the aspect added.
        assertTrue(nodeService.hasAspect(fileA, ContentModel.ASPECT_CLASSIFIABLE));
        assertTrue(nodeService.hasAspect(folderB, ContentModel.ASPECT_CLASSIFIABLE));
        // The contents of folderB will all have the aspect added.
        assertTrue(nodeService.hasAspect(fileB, ContentModel.ASPECT_CLASSIFIABLE));
        return null;
    });
}
 

public void testAspectRemovalWithCommit() throws Throwable
{
   // Create a node to add the aspect to
   NodeRef sourceNodeRef = nodeService.createNode(
           rootNodeRef,
           ASSOC_TYPE_QNAME_TEST_CHILDREN,
           QName.createQName(BaseNodeServiceTest.NAMESPACE, "testAspectRemoval-source"),
           ContentModel.TYPE_CONTAINER).getChildRef();
   
   // Create a target for the associations
   NodeRef targetNodeRef = nodeService.createNode(
           rootNodeRef,
           ASSOC_TYPE_QNAME_TEST_CHILDREN,
           QName.createQName(BaseNodeServiceTest.NAMESPACE, "testAspectRemoval-target"),
           ContentModel.TYPE_CONTAINER).getChildRef();
   
   // Add the aspect to the source
   nodeService.addAspect(sourceNodeRef, ASPECT_WITH_ASSOCIATIONS, null);
   // Make the associations
   nodeService.addChild(
           sourceNodeRef,
           targetNodeRef,
           ASSOC_ASPECT_CHILD_ASSOC,
           QName.createQName(NAMESPACE, "aspect-child"));
   nodeService.createAssociation(sourceNodeRef, targetNodeRef, ASSOC_ASPECT_NORMAL_ASSOC);
   
   // Check that the correct associations are present
   assertEquals("Expected exactly one child",
           1, nodeService.getChildAssocs(sourceNodeRef).size());
   assertEquals("Expected exactly one target",
           1, nodeService.getTargetAssocs(sourceNodeRef, RegexQNamePattern.MATCH_ALL).size());
   
   // Force a commit here
    TestTransaction.flagForCommit();
    TestTransaction.end();
   
   // start another transaction to remove the aspect
   UserTransaction txn = txnService.getUserTransaction();
   txn.begin();
   
   try
   {
      Set<QName> aspects = nodeService.getAspects(sourceNodeRef); 
      int noAspectsBefore = aspects.size();
      
      // Now remove the aspect
      nodeService.removeAspect(sourceNodeRef, ASPECT_WITH_ASSOCIATIONS);
      
      // Check that the associations were removed
      assertEquals("Expected exactly zero child",
              0, nodeService.getChildAssocs(sourceNodeRef).size());
      assertEquals("Expected exactly zero target",
              0, nodeService.getTargetAssocs(sourceNodeRef, RegexQNamePattern.MATCH_ALL).size());
      aspects = nodeService.getAspects(sourceNodeRef); 
      assertEquals("Expected exactly one less aspect",
              noAspectsBefore-1, aspects.size());
      
      txn.commit();
   }
   catch (Throwable e)
   {
       try { txn.rollback(); } catch (Throwable ee) {}
       throw e;
   }
}
 

@Test
public void testOnContentCreateTrigger()
{
    TestRuleType nodeCreate = createTestRuleType(ON_CREATE_NODE_TRIGGER);
    assertFalse(nodeCreate.rulesTriggered);

    NodeRef nodeRef = this.nodeService.createNode(
            this.rootNodeRef,
            ContentModel.ASSOC_CHILDREN,
            ContentModel.ASSOC_CHILDREN,
            ContentModel.TYPE_CONTENT).getChildRef();
    
    assertTrue(nodeCreate.rulesTriggered);

    // Terminate the transaction
    TestTransaction.flagForCommit();
    TestTransaction.end();
    TestTransaction.start();

    TestRuleType contentCreate = createTestRuleType(ON_CONTENT_CREATE_TRIGGER);
    assertFalse(contentCreate.rulesTriggered);
    
    // Try and trigger the type
    ContentWriter contentWriter = this.contentService.getWriter(nodeRef, ContentModel.PROP_CONTENT, true);
    contentWriter.setMimetype(MimetypeMap.MIMETYPE_TEXT_PLAIN);
    contentWriter.setEncoding("UTF-8");
    contentWriter.putContent("some content");
    
    // Check to see if the rule type has been triggered
    assertTrue(contentCreate.rulesTriggered);
    
    // Try and trigger the type (again)
    contentCreate.rulesTriggered = false;
    assertFalse(contentCreate.rulesTriggered);
    ContentWriter contentWriter2 = this.contentService.getWriter(nodeRef, ContentModel.PROP_CONTENT, true);
    contentWriter2.setMimetype(MimetypeMap.MIMETYPE_TEXT_PLAIN);
    contentWriter2.setEncoding("UTF-8");
    contentWriter2.putContent("some content");
    
    // Check to see if the rule type has been triggered
    assertFalse(contentCreate.rulesTriggered);
}
 

/**
 * Check that the maximum string lengths can be adjusted up and down.
 * Note that this test ONLY works for MySQL because the other databases cannot support more than 1024 characters
 * in the string_value column and the value may not be set to less than 1024.
 * 
 * @see SchemaBootstrap#DEFAULT_MAX_STRING_LENGTH
 */
@SuppressWarnings("deprecation")
public void testMySQLInnoDBNodeStringLengthWorker() throws Exception
{
    TestTransaction.flagForCommit();
    TestTransaction.end();
    
    // Skip of the dialect if not MySQL (also skip for MySQL Cluster NDB)
    Dialect dialect = (Dialect) applicationContext.getBean("dialect");
    if ((dialect instanceof MySQLClusterNDBDialect) || (! (dialect instanceof MySQLInnoDBDialect)))
    {
        return;
    }
    SchemaBootstrap schemaBootstrap = (SchemaBootstrap) applicationContext.getBean("schemaBootstrap");
    assertEquals("Expected max string length to be MAX", Integer.MAX_VALUE, SchemaBootstrap.getMaxStringLength());
    
    NodeStringLengthWorker worker = (NodeStringLengthWorker) applicationContext.getBean("nodeStringLengthWorker");
    
    // If we run this worker just to get everything into the correct starting state.
    // If it does not work, then that will be detected later anyway
    NodeStringLengthWorkResult result = worker.execute();
    assertTrue(result.getPropertiesProcessed() > 0);
    assertEquals(0, result.getErrors());
    
    // Now set the max string length to DEFAULT_MAX_STRING_LENGTH characters
    schemaBootstrap.setMaximumStringLength(SchemaBootstrap.DEFAULT_MAX_STRING_LENGTH);
    schemaBootstrap.onApplicationEvent(new ContextRefreshedEvent(applicationContext));
    // Move any values persisted before the test
    result = worker.execute();
    int firstPassChanged = result.getPropertiesChanged();
    
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < SchemaBootstrap.DEFAULT_MAX_STRING_LENGTH + 1; i++)
    {
        sb.append("A");
    }
    final String longString = sb.toString();
    // Persist the property using the default MAX_VALUE so that it goes into the string_value
    schemaBootstrap.setMaximumStringLength(Integer.MAX_VALUE);
    schemaBootstrap.onApplicationEvent(new ContextRefreshedEvent(applicationContext));
    txnService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>()
    {
        @Override
        public Void execute() throws Throwable
        {
            nodeService.setProperty(rootNodeRef, PROP_QNAME_STRING_VALUE, longString);
            return null;
        }
    });

    // The worker should do nothing
    result = worker.execute();
    assertEquals(firstPassChanged, result.getPropertiesChanged());
    
    // Now bring the limit down to the match for other DBs
    schemaBootstrap.setMaximumStringLength(SchemaBootstrap.DEFAULT_MAX_STRING_LENGTH);
    schemaBootstrap.onApplicationEvent(new ContextRefreshedEvent(applicationContext));
    result = worker.execute();
    assertEquals(firstPassChanged + 1, result.getPropertiesChanged());
    
    // Put the limit back to the MySQL default and all the large values should go back into MySQL's TEXT field
    schemaBootstrap.setMaximumStringLength(Integer.MAX_VALUE);
    schemaBootstrap.onApplicationEvent(new ContextRefreshedEvent(applicationContext));
    result = worker.execute();
    assertEquals(firstPassChanged + 1, result.getPropertiesChanged());
    
    // Check that our string is still OK
    String checkLongString = txnService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<String>()
    {
        @Override
        public String execute() throws Throwable
        {
            return (String) nodeService.getProperty(rootNodeRef, PROP_QNAME_STRING_VALUE);
        }
    });
    assertEquals("String manipulation corrupted the long string value. ", longString, checkLongString);
}
 

@Test
public void testImportingSameNamespaceFails() throws Exception
{
    // just to make sure we don't regress ACE-5852, some tests should run as System
    AuthenticationUtil.setFullyAuthenticatedUser(AuthenticationUtil.getSystemUserName());

    // Create model
    final NodeRef modelNode = createActiveModel("dictionary/testModel.xml");
    TestTransaction.flagForCommit();
    TestTransaction.end();

    //  add second model to introduce self referencing dependency
    TestTransaction.start();
    PropertyMap properties = new PropertyMap(1);
    properties.put(ContentModel.PROP_MODEL_ACTIVE, true);
    final NodeRef modelNode2 = this.nodeService.createNode(
             this.rootNodeRef,
             ContentModel.ASSOC_CHILDREN,
             QName.createQName(NamespaceService.ALFRESCO_URI, "dictionaryModels"),
             ContentModel.TYPE_DICTIONARY_MODEL,
             properties).getChildRef();
    TestTransaction.flagForCommit();
    TestTransaction.end();

    try
    {
        transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
                public Void execute() throws Exception {
                    ContentWriter contentWriter = DictionaryModelTypeTest.this.contentService.getWriter(modelNode2, ContentModel.PROP_CONTENT, true);
                    contentWriter.putContent(Thread.currentThread().getContextClassLoader().getResourceAsStream("dictionary/testModel2.xml"));
                    return null;
                }
        });
        fail("Validation should fail as a circular dependency was introduced");
    } catch(AlfrescoRuntimeException e)
    {
        assertTrue(e.getCause().getMessage().contains("URI mage.model cannot be imported as it is already contained in the model's namespaces"));
    }

    //delete model
    finally
    {
        transactionService.getRetryingTransactionHelper().doInTransaction(
                new RetryingTransactionCallback<Object>() {
                    public Object execute() throws Exception {
                        // Delete the model
                        DictionaryModelTypeTest.this.nodeService.deleteNode(modelNode);
                        return null;
                    }
                });
    }
}
 

@Before
public void before() throws Exception
{
    super.before();
    this.namespaceService= (NamespaceService) this.applicationContext.getBean("namespaceService");
    this.renditionService = (RenditionService) this.applicationContext.getBean("renditionService");
    this.repositoryHelper = (Repository) this.applicationContext.getBean("repositoryHelper");
    this.scriptService = (ScriptService) this.applicationContext.getBean("scriptService");
    this.transactionHelper = (RetryingTransactionHelper) this.applicationContext
                .getBean("retryingTransactionHelper");

    // Set the current security context as admin
    AuthenticationUtil.setFullyAuthenticatedUser(AuthenticationUtil.getAdminUserName());
    
    // Register our test rendering engine if needed
    DummyHelloWorldRenditionEngine.registerIfNeeded(this.applicationContext);

    // Create test folders
    NodeRef companyHome = this.repositoryHelper.getCompanyHome();

    // Create the test folder used for these tests
    this.testTargetFolder = createNode(companyHome, "testFolder-" + GUID.generate(), ContentModel.TYPE_FOLDER);

    // Create the node used as a content supplier for tests
    this.nodeWithDocContent  =  createContentNode(companyHome, "testDocContent-" + GUID.generate());
    
    // Put some known PDF content in it.
    File pdfQuickFile = AbstractContentTransformerTest.loadQuickTestFile("pdf");
    assertNotNull("Failed to load required test file.", pdfQuickFile);

    nodeService.setProperty(nodeWithDocContent, ContentModel.PROP_CONTENT, new ContentData(null,
                MimetypeMap.MIMETYPE_PDF, 0L, null));
    ContentWriter writer = contentService.getWriter(nodeWithDocContent, ContentModel.PROP_CONTENT, true);
    writer.setMimetype(MimetypeMap.MIMETYPE_PDF);
    writer.setEncoding("UTF-8");
    writer.putContent(pdfQuickFile);
    
    // Put the titled aspect on it - used for testing rendition updates
    Map<QName, Serializable> titledProps = new HashMap<QName, Serializable>();
    titledProps.put(ContentModel.PROP_TITLE, "Original test title");
    titledProps.put(ContentModel.PROP_DESCRIPTION, "Dummy description");
    nodeService.addAspect(nodeWithDocContent, ContentModel.ASPECT_TITLED, titledProps);


    // Create a test image
    this.nodeWithImageContent = createContentNode(companyHome, "testImageNode-" + GUID.generate());
    // Stream some well-known image content into the node.       
    URL url = RenditionServiceIntegrationTest.class.getClassLoader().getResource("images/gray21.512.png");
    assertNotNull("url of test image was null", url);
    File imageFile = new File(url.getFile());
    setImageContentOnNode(nodeWithImageContent, MimetypeMap.MIMETYPE_IMAGE_PNG, imageFile);

    // Create a test template node.
    this.nodeWithFreeMarkerContent = createFreeMarkerNode(companyHome);
    TestTransaction.flagForCommit();
    TestTransaction.end();
    TestTransaction.start();
}
 

/**
 * Inbound rule must not be applied on failed thumbnail
 * 
 * see MNT-10914
 */
@Test
public void testRuleExecutionOnFailedThumbnailChild() throws Exception
{
    // create inbound rule on folder
    Map<String, Serializable> params = new HashMap<String, Serializable>(1);
    params.put("aspect-name", ContentModel.ASPECT_GEN_CLASSIFIABLE);
    Rule rule = new Rule();
    rule.setRuleType(RuleType.INBOUND);
    Action action = this.actionService.createAction(AddFeaturesActionExecuter.NAME, params);
    ActionCondition condition = this.actionService.createActionCondition(NoConditionEvaluator.NAME, null);
    action.addActionCondition(condition);
    rule.setAction(action);
    rule.applyToChildren(true);
    services.getRuleService().saveRule(folder, rule);

    TestTransaction.flagForCommit();
    TestTransaction.end();

    final NodeRef corruptNode = transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionHelper.RetryingTransactionCallback<NodeRef>()
    {
        public NodeRef execute() throws Throwable
        {
            return createCorruptedContent(folder);
        }
    });
    // Make sure the source node is correctly set up before we start
    // It should not be renditioned and should not be marked as having any failed thumbnails.
    assertFalse(secureNodeService.hasAspect(corruptNode, ContentModel.ASPECT_FAILED_THUMBNAIL_SOURCE));

    // Attempt to perform a thumbnail that we know will fail.
    transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionHelper.RetryingTransactionCallback<Void>()
    {
        public Void execute() throws Throwable
        {
            ThumbnailDefinition thumbnailDef = thumbnailService.getThumbnailRegistry().getThumbnailDefinition("doclib");
            Action createThumbnailAction = ThumbnailHelper.createCreateThumbnailAction(thumbnailDef, services);
            actionService.executeAction(createThumbnailAction, corruptNode, true, true);
            return null;
        }
    });
    // The thumbnail attempt has now failed. But a compensating action should have been scheduled that will mark the
    // source node with a failure aspect. As that is an asynchronous action, we need to wait for that to complete.

    Thread.sleep(3000); // This should be long enough for the compensating action to run.

    final NodeRef failedThumbnailNode = transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionHelper.RetryingTransactionCallback<NodeRef>()
    {
        public NodeRef execute() throws Throwable
        {
            assertTrue("corrupt node should have failed thumbnails aspect", secureNodeService.hasAspect(corruptNode, ContentModel.ASPECT_FAILED_THUMBNAIL_SOURCE));

            Map<String, FailedThumbnailInfo> failedThumbnails = thumbnailService.getFailedThumbnails(corruptNode);
            assertEquals("Wrong number of failed thumbnails", 1, failedThumbnails.size());

            assertTrue("Missing QName for failed thumbnail", failedThumbnails.containsKey("doclib"));
            final FailedThumbnailInfo doclibFailureInfo = failedThumbnails.get("doclib");
            assertNotNull("Failure info was null", doclibFailureInfo);

            return doclibFailureInfo.getFailedThumbnailNode();
        }
    });

    assertTrue("Rule must not be executed on document", secureNodeService.hasAspect(corruptNode, ContentModel.ASPECT_GEN_CLASSIFIABLE));
    assertFalse("Rule must not be executed on failed thumbnail", secureNodeService.hasAspect(failedThumbnailNode, ContentModel.ASPECT_GEN_CLASSIFIABLE));
}
 

/**
 * Test execution as per MNT-13055.
 * <p>
 * When we use the ExecuteAllRulesActionExecuter to explicitly (e.g. "manually")
 * execute all the rules on a folder and its subfolders, the rule must correctly
 * recurse into those subfolders. This is a more simple test case than the steps
 * described in the above issue, but is crucial to the more complicated case
 * succeeding.
 */
public void testRuleAppliesToSubfoldersSuccessfully()
{
    final NodeRef rootFolder = this.nodeService.createNode(
            this.rootNodeRef,
            ContentModel.ASSOC_CHILDREN,
            QName.createQName("{test}rootFolderForTest"),
            ContentModel.TYPE_FOLDER).getChildRef();

    final NodeRef folderA = fileFolderService.
            create(rootFolder, "folderA", ContentModel.TYPE_FOLDER).getNodeRef();

    NodeRef fileA = createFile(folderA, "fileA.txt").getNodeRef();

    final NodeRef folderB = fileFolderService.
            create(folderA, "folderB", ContentModel.TYPE_FOLDER).getNodeRef();

    NodeRef fileB = createFile(folderB, "fileB.txt").getNodeRef();

    TestTransaction.flagForCommit();
    TestTransaction.end();

    // On RootFolder create a rule
    transactionHelper.doInTransaction(() -> {
        Rule rule1 = new Rule();
        rule1.setRuleType(RuleType.INBOUND);
        Action action1 = actionService.createAction(AddFeaturesActionExecuter.NAME);
        action1.setParameterValue(AddFeaturesActionExecuter.PARAM_ASPECT_NAME, ContentModel.ASPECT_CLASSIFIABLE);
        rule1.setAction(action1);
        rule1.applyToChildren(true);
        rule1.setExecuteAsynchronously(false);
        ruleService.enableRule(rule1);
        ruleService.saveRule(rootFolder, rule1);
        return null;
    });
    
    // Check the the docs don't have the aspects yet
    transactionHelper.doInTransaction(() -> {
        assertFalse(nodeService.hasAspect(folderA, ContentModel.ASPECT_CLASSIFIABLE));
        assertFalse(nodeService.hasAspect(folderB, ContentModel.ASPECT_CLASSIFIABLE));
        assertFalse(nodeService.hasAspect(fileA, ContentModel.ASPECT_CLASSIFIABLE));
        assertFalse(nodeService.hasAspect(fileB, ContentModel.ASPECT_CLASSIFIABLE));
        return null;
    });
    
    // Execute the action
    transactionHelper.doInTransaction(() -> {
        Map<String, Serializable> actionParams = new HashMap<>();
        actionParams.put(ExecuteAllRulesActionExecuter.PARAM_RUN_ALL_RULES_ON_CHILDREN, true);
        actionParams.put(ExecuteAllRulesActionExecuter.PARAM_EXECUTE_INHERITED_RULES, true);
        Action action = actionService.createAction(ExecuteAllRulesActionExecuter.NAME, actionParams);
        executer.execute(action, rootFolder);
        return null;
    });
    
    transactionHelper.doInTransaction(() -> {
        assertTrue(nodeService.hasAspect(folderA, ContentModel.ASPECT_CLASSIFIABLE));
        assertTrue(nodeService.hasAspect(folderB, ContentModel.ASPECT_CLASSIFIABLE));
        assertTrue(nodeService.hasAspect(fileA, ContentModel.ASPECT_CLASSIFIABLE));
        assertTrue(nodeService.hasAspect(fileB, ContentModel.ASPECT_CLASSIFIABLE));
        return null;
    });
}
 

@Test
public void whenProgrammaticTransactionCommit_thenEntityIsInDatabase() {
    assertTrue(TestTransaction.isActive());

    //Save an entity and commit.
    Session session = sessionFactory.getCurrentSession();

    TestEntity newEntity = new TestEntity();
    newEntity.setId(1);
    session.save(newEntity);

    TestEntity searchEntity = session.find(TestEntity.class, 1);

    Assert.assertNotNull(searchEntity);
    assertTrue(TestTransaction.isFlaggedForRollback());

    TestTransaction.flagForCommit();
    TestTransaction.end();

    assertFalse(TestTransaction.isFlaggedForRollback());
    assertFalse(TestTransaction.isActive());

    //Check that the entity is still there in a new transaction,
    //then delete it, but don't commit.
    TestTransaction.start();

    assertTrue(TestTransaction.isFlaggedForRollback());
    assertTrue(TestTransaction.isActive());

    session = sessionFactory.getCurrentSession();
    searchEntity = session.find(TestEntity.class, 1);

    Assert.assertNotNull(searchEntity);

    session.delete(searchEntity);
    session.flush();

    TestTransaction.end();

    assertFalse(TestTransaction.isActive());

    //Check that the entity is still there in a new transaction,
    //then delete it and commit.
    TestTransaction.start();

    session = sessionFactory.getCurrentSession();
    searchEntity = session.find(TestEntity.class, 1);

    Assert.assertNotNull(searchEntity);

    session.delete(searchEntity);
    session.flush();

    assertTrue(TestTransaction.isActive());

    TestTransaction.flagForCommit();
    TestTransaction.end();

    assertFalse(TestTransaction.isActive());

    //Check that the entity is no longer there in a new transaction.
    TestTransaction.start();

    assertTrue(TestTransaction.isActive());

    session = sessionFactory.getCurrentSession();
    searchEntity = session.find(TestEntity.class, 1);

    Assert.assertNull(searchEntity);
}