mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-08-07 17:49:17 +00:00
33a3a89e34
93784: ALF-21099 - Unit test correction. git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@94992 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
739 lines
31 KiB
Java
739 lines
31 KiB
Java
/*
|
|
* Copyright (C) 2005-2014 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.action.executer;
|
|
|
|
import java.io.IOException;
|
|
import java.io.Serializable;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import javax.mail.Address;
|
|
import javax.mail.Message;
|
|
import javax.mail.MessagingException;
|
|
import javax.mail.internet.InternetAddress;
|
|
import javax.mail.internet.MimeMessage;
|
|
import javax.mail.internet.MimeMessage.RecipientType;
|
|
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.repo.management.subsystems.ApplicationContextFactory;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil.RunAsWork;
|
|
import org.alfresco.repo.tenant.TenantService;
|
|
import org.alfresco.repo.tenant.TenantUtil;
|
|
import org.alfresco.repo.tenant.TenantUtil.TenantRunAsWork;
|
|
import org.alfresco.repo.transaction.RetryingTransactionHelper;
|
|
import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
|
|
import org.alfresco.service.cmr.action.Action;
|
|
import org.alfresco.service.cmr.action.ActionService;
|
|
import org.alfresco.service.cmr.preference.PreferenceService;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
import org.alfresco.service.cmr.security.AuthorityService;
|
|
import org.alfresco.service.cmr.security.AuthorityType;
|
|
import org.alfresco.service.cmr.security.PermissionService;
|
|
import org.alfresco.service.cmr.security.PersonService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.service.transaction.TransactionService;
|
|
import org.alfresco.util.PropertyMap;
|
|
import org.alfresco.util.test.junitrules.AlfrescoPerson;
|
|
import org.alfresco.util.test.junitrules.ApplicationContextInit;
|
|
import org.junit.Assert;
|
|
import org.junit.Test;
|
|
import org.springframework.context.ApplicationContext;
|
|
|
|
/**
|
|
* Provides tests for the MailActionExecuter class. Most of this logic was in MailActionExecuterTest.
|
|
* Cloud code now includes extra tests and different rule config.
|
|
* Unfortunately this is messy due to the extensive use of static variables and Junit rules annotations.
|
|
* This class contains most of the test code, child classes actually setup the ClassRules and test fixtures, of
|
|
* particular importance is the static setupRuleChain() method in the child classes. The name is just a convention because
|
|
* it can't actually be enforced. The setupRuleChain() actually creates the users, as well as ordering the rules.
|
|
* You will see the AlfrescoPerson variables below are initialized as null, the assumption is that the child classes will
|
|
* create these users before they are needed (in the setupRuleChain() method), again this can't be enforced :(.
|
|
*
|
|
*/
|
|
public abstract class AbstractMailActionExecuterTest
|
|
{
|
|
|
|
// Rule to initialise the default Alfresco spring configuration
|
|
public static ApplicationContextInit APP_CONTEXT_INIT = new ApplicationContextInit();
|
|
|
|
// Rules to create test users, these are actually created in the setupRuleChain() method of child classes.
|
|
public static AlfrescoPerson BRITISH_USER = null;
|
|
public static AlfrescoPerson FRENCH_USER = null;
|
|
public static AlfrescoPerson AUSTRALIAN_USER = null;
|
|
public static AlfrescoPerson EXTERNAL_USER = null;
|
|
|
|
private static String ALFRESCO_EE_USER = "plainUser";
|
|
|
|
protected static TransactionService TRANSACTION_SERVICE;
|
|
protected static ActionService ACTION_SERVICE;
|
|
protected static MailActionExecuter ACTION_EXECUTER;
|
|
protected static PreferenceService PREFERENCE_SERVICE;
|
|
protected static PersonService PERSON_SERVICE;
|
|
protected static AuthorityService AUTHORITY_SERVICE;
|
|
protected static NodeService NODE_SERVICE;
|
|
protected static PermissionService PERMISSION_SERVICE;
|
|
|
|
protected static boolean WAS_IN_TEST_MODE;
|
|
|
|
public static void setupTests(ApplicationContext appCtx)
|
|
{
|
|
TRANSACTION_SERVICE = appCtx.getBean("TransactionService", TransactionService.class);
|
|
ACTION_SERVICE = appCtx.getBean("ActionService", ActionService.class);
|
|
ACTION_EXECUTER = appCtx.getBean("OutboundSMTP", ApplicationContextFactory.class).getApplicationContext().getBean("mail", MailActionExecuter.class);
|
|
PREFERENCE_SERVICE = appCtx.getBean("PreferenceService", PreferenceService.class);
|
|
PERSON_SERVICE = appCtx.getBean("PersonService", PersonService.class);
|
|
NODE_SERVICE = appCtx.getBean("NodeService", NodeService.class);
|
|
AUTHORITY_SERVICE = appCtx.getBean("AuthorityService", AuthorityService.class);
|
|
PERMISSION_SERVICE = appCtx.getBean("PermissionService", PermissionService.class);
|
|
|
|
WAS_IN_TEST_MODE = ACTION_EXECUTER.isTestMode();
|
|
ACTION_EXECUTER.setTestMode(true);
|
|
|
|
AuthenticationUtil.setRunAsUserSystem();
|
|
|
|
Map<QName, Serializable> properties = new HashMap<QName, Serializable>(1);
|
|
properties.put(ContentModel.PROP_USERNAME, ALFRESCO_EE_USER);
|
|
properties.put(ContentModel.PROP_EMAIL, "testemail@testdomain.com");
|
|
PERSON_SERVICE.createPerson(properties, null);
|
|
|
|
// All these test users are in the same tenant - either they're enterprise where there's only one,
|
|
// or they're cloud, where they have the same email domain
|
|
final String tenantId = getUsersHomeTenant(FRENCH_USER.getUsername());
|
|
TenantUtil.runAsSystemTenant(new TenantRunAsWork<Object>()
|
|
{
|
|
@Override
|
|
public Object doWork() throws Exception
|
|
{
|
|
final Map<String, Serializable> preferences = new HashMap<String, Serializable>();
|
|
|
|
preferences.put("locale", "fr");
|
|
PREFERENCE_SERVICE.setPreferences(FRENCH_USER.getUsername(), preferences);
|
|
|
|
preferences.clear();
|
|
preferences.put("locale", "en_GB");
|
|
PREFERENCE_SERVICE.setPreferences(BRITISH_USER.getUsername(), preferences);
|
|
|
|
preferences.clear();
|
|
preferences.put("locale", "en_AU");
|
|
PREFERENCE_SERVICE.setPreferences(AUSTRALIAN_USER.getUsername(), preferences);
|
|
|
|
return null;
|
|
}
|
|
}, tenantId);
|
|
}
|
|
|
|
private static String getUsersHomeTenant(String userName)
|
|
{
|
|
boolean thisIsCloud = false;
|
|
try
|
|
{
|
|
thisIsCloud = (Class.forName("org.alfresco.module.org_alfresco_module_cloud.registration.RegistrationService") != null);
|
|
}
|
|
catch (ClassNotFoundException ignoreIfThrown)
|
|
{
|
|
// Intentionally empty
|
|
}
|
|
|
|
String result = TenantService.DEFAULT_DOMAIN;
|
|
|
|
// Even if we get email address-style user names in an enterprise system, those are not to be given home tenants.
|
|
if (thisIsCloud)
|
|
{
|
|
String[] elems = userName.split("@");
|
|
result = elems[1];
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
public static void tearDownTests()
|
|
{
|
|
ACTION_EXECUTER.setTestMode(WAS_IN_TEST_MODE);
|
|
PERSON_SERVICE.deletePerson(ALFRESCO_EE_USER);
|
|
}
|
|
|
|
@Test
|
|
public void testUnknownRecipientUnknownSender() throws IOException, MessagingException
|
|
{
|
|
// PARAM_TO variant
|
|
Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_FROM, "some.body@example.com");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO, "some.bodyelse@example.com");
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE, "alfresco/templates/mail/test.txt.ftl");
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE_MODEL, (Serializable) getModel());
|
|
|
|
ACTION_SERVICE.executeAction(mailAction, null);
|
|
|
|
MimeMessage message = ACTION_EXECUTER.retrieveLastTestMessage();
|
|
Assert.assertNotNull(message);
|
|
Assert.assertEquals("Hello Jan 1, 1970", (String) message.getContent());
|
|
}
|
|
|
|
@Test
|
|
public void testUnknownRecipientUnknownSender_ToMany() throws IOException, MessagingException
|
|
{
|
|
// PARAM_TO_MANY variant - this code path currently has separate validation FIXME fix this.
|
|
Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_FROM, "some.body@example.com");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO_MANY, "some.bodyelse@example.com");
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE, "alfresco/templates/mail/test.txt.ftl");
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE_MODEL, (Serializable) getModel());
|
|
|
|
ACTION_SERVICE.executeAction(mailAction, null);
|
|
|
|
MimeMessage message = ACTION_EXECUTER.retrieveLastTestMessage();
|
|
Assert.assertNotNull(message);
|
|
Assert.assertEquals("Hello Jan 1, 1970", (String) message.getContent());
|
|
}
|
|
|
|
private Serializable getModel()
|
|
{
|
|
Map<String, Object> model = new HashMap<String, Object>();
|
|
|
|
model.put("epoch", new Date(0));
|
|
return (Serializable) model;
|
|
}
|
|
|
|
@Test
|
|
public void testFrenchRecipient() throws IOException, MessagingException
|
|
{
|
|
String from = "some.body@example.com";
|
|
Serializable recipients = (Serializable) Arrays.asList(FRENCH_USER.getUsername());
|
|
String subject = "";
|
|
String template = "alfresco/templates/mail/test.txt.ftl";
|
|
|
|
MimeMessage message = sendMessage(from, recipients, subject, template);
|
|
|
|
Assert.assertNotNull(message);
|
|
Assert.assertEquals("Bonjour 1 janv. 1970", (String) message.getContent());
|
|
}
|
|
|
|
protected MimeMessage sendMessage(String from, Serializable recipients, String subject, String template)
|
|
{
|
|
Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO_MANY, recipients);
|
|
|
|
return sendMessage(from, subject, template, mailAction);
|
|
}
|
|
|
|
protected MimeMessage sendMessage(String from, String subject, String template, final Action mailAction)
|
|
{
|
|
if (from != null)
|
|
{
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_FROM, from);
|
|
}
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, subject);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE, template);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE_MODEL, getModel());
|
|
|
|
RetryingTransactionHelper txHelper = APP_CONTEXT_INIT.getApplicationContext().getBean("retryingTransactionHelper", RetryingTransactionHelper.class);
|
|
|
|
return txHelper.doInTransaction(new RetryingTransactionCallback<MimeMessage>()
|
|
{
|
|
@Override
|
|
public MimeMessage execute() throws Throwable
|
|
{
|
|
ACTION_SERVICE.executeAction(mailAction, null);
|
|
|
|
return ACTION_EXECUTER.retrieveLastTestMessage();
|
|
}
|
|
}, true);
|
|
}
|
|
|
|
protected MimeMessage sendMessage(String from, String to, String subject, String template)
|
|
{
|
|
Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO, to);
|
|
return sendMessage(from, subject, template, mailAction);
|
|
}
|
|
|
|
/**
|
|
* Test for ALF-19231
|
|
*/
|
|
@Test
|
|
public void testSendMailActionForUserNameAsRecipient() throws IOException, MessagingException
|
|
{
|
|
String from = BRITISH_USER.getUsername();
|
|
Serializable recipients = (Serializable) Arrays.asList(ALFRESCO_EE_USER);
|
|
String subject = "Testing";
|
|
String template = "alfresco/templates/mail/test.txt.ftl";
|
|
|
|
MimeMessage message = sendMessage(from, recipients, subject, template);
|
|
|
|
Assert.assertNotNull(message);
|
|
Assert.assertEquals("Hello 01-Jan-1970", (String) message.getContent());
|
|
}
|
|
|
|
@Test
|
|
public void testUnknowRecipientAustralianSender() throws IOException, MessagingException
|
|
{
|
|
String from = AUSTRALIAN_USER.getUsername();
|
|
String to = "some.body@example.com";
|
|
String subject = "Testing";
|
|
String template = "alfresco/templates/mail/test.txt.ftl";
|
|
|
|
MimeMessage message = sendMessage(from, to, subject, template);
|
|
|
|
Assert.assertNotNull(message);
|
|
Assert.assertEquals("G'Day 01/01/1970", (String) message.getContent());
|
|
}
|
|
|
|
@Test
|
|
public void testSendingTestMessageWithNoCurrentUser()
|
|
{
|
|
try
|
|
{
|
|
// run with no current user
|
|
AuthenticationUtil.clearCurrentSecurityContext();
|
|
|
|
final Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO, "some.body@eaxmple.com");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEXT, "This is a test message.");
|
|
|
|
TRANSACTION_SERVICE.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>()
|
|
{
|
|
@Override
|
|
public Void execute() throws Throwable
|
|
{
|
|
ACTION_EXECUTER.executeImpl(mailAction, null);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
finally
|
|
{
|
|
// restore system user as current user
|
|
AuthenticationUtil.setRunAsUserSystem();
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testPrepareEmailForDisabledUsers() throws MessagingException
|
|
{
|
|
String groupName = null;
|
|
final String USER1 = "test_user1";
|
|
final String USER2 = "test_user2";
|
|
try
|
|
{
|
|
createUser(USER1, null);
|
|
NodeRef userNode = createUser(USER2, null);
|
|
groupName = AUTHORITY_SERVICE.createAuthority(AuthorityType.GROUP, "testgroup1");
|
|
AUTHORITY_SERVICE.addAuthority(groupName, USER1);
|
|
AUTHORITY_SERVICE.addAuthority(groupName, USER2);
|
|
NODE_SERVICE.addAspect(userNode, ContentModel.ASPECT_PERSON_DISABLED, null);
|
|
final Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_FROM, "some.body@example.com");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO_MANY, groupName);
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEXT, "Testing");
|
|
|
|
RetryingTransactionHelper txHelper = APP_CONTEXT_INIT.getApplicationContext().getBean("retryingTransactionHelper", RetryingTransactionHelper.class);
|
|
|
|
MimeMessage mm = txHelper.doInTransaction(new RetryingTransactionCallback<MimeMessage>()
|
|
{
|
|
@Override
|
|
public MimeMessage execute() throws Throwable
|
|
{
|
|
return ACTION_EXECUTER.prepareEmail(mailAction, null, null, null).getMimeMessage();
|
|
}
|
|
}, true);
|
|
|
|
Address[] addresses = mm.getRecipients(Message.RecipientType.TO);
|
|
Assert.assertEquals(1, addresses.length);
|
|
Assert.assertEquals(USER1 + "@email.com", addresses[0].toString());
|
|
}
|
|
finally
|
|
{
|
|
if (groupName != null)
|
|
{
|
|
AUTHORITY_SERVICE.deleteAuthority(groupName, true);
|
|
}
|
|
PERSON_SERVICE.deletePerson(USER1);
|
|
PERSON_SERVICE.deletePerson(USER2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a test user with the specified username and optionally custom email.
|
|
*
|
|
* @param userName
|
|
* @param email Optional, if not specified assigned to <code>userName + "@email.com"</code>
|
|
* @return
|
|
*/
|
|
private NodeRef createUser(String userName, String email)
|
|
{
|
|
PropertyMap personProps = new PropertyMap();
|
|
personProps.put(ContentModel.PROP_USERNAME, userName);
|
|
personProps.put(ContentModel.PROP_FIRSTNAME, userName);
|
|
personProps.put(ContentModel.PROP_LASTNAME, userName);
|
|
if (email != null)
|
|
{
|
|
personProps.put(ContentModel.PROP_EMAIL, email);
|
|
}
|
|
else
|
|
{
|
|
personProps.put(ContentModel.PROP_EMAIL, userName + "@email.com");
|
|
}
|
|
|
|
return PERSON_SERVICE.createPerson(personProps);
|
|
}
|
|
|
|
/**
|
|
* Test for MNT-10874
|
|
* @throws Exception
|
|
*/
|
|
@Test
|
|
public void testUserWithNonExistingTenant() throws Exception
|
|
{
|
|
final String USER_WITH_NON_EXISTING_TENANT = "test_user_non_tenant@non_existing_tenant.com";
|
|
|
|
try
|
|
{
|
|
createUser(USER_WITH_NON_EXISTING_TENANT, USER_WITH_NON_EXISTING_TENANT);
|
|
|
|
final Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO, USER_WITH_NON_EXISTING_TENANT);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEXT, "This is a test message.");
|
|
|
|
// run as non admin and non system
|
|
AuthenticationUtil.setFullyAuthenticatedUser(BRITISH_USER.getUsername());
|
|
TRANSACTION_SERVICE.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>()
|
|
{
|
|
@Override
|
|
public Void execute() throws Throwable
|
|
{
|
|
ACTION_EXECUTER.executeImpl(mailAction, null);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
finally
|
|
{
|
|
// restore system user as current user
|
|
AuthenticationUtil.setRunAsUserSystem();
|
|
// tidy up
|
|
PERSON_SERVICE.deletePerson(USER_WITH_NON_EXISTING_TENANT);
|
|
AuthenticationUtil.clearCurrentSecurityContext();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test for MNT-11488
|
|
* @throws Exception
|
|
*/
|
|
@Test
|
|
public void testSendingToMultipleUsers() throws IOException, MessagingException
|
|
{
|
|
final String USER_1 = "recipient1";
|
|
final String USER_2 = "recipient2";
|
|
final String[] recipientsArray = { USER_1 + "@email.com", USER_2 + "@email.com" };
|
|
final List<String> recipientsResult = new ArrayList<String>(Arrays.asList(recipientsArray)) ;
|
|
|
|
try
|
|
{
|
|
createUser(USER_1, null);
|
|
createUser(USER_2, null);
|
|
ArrayList<String> recipients = new ArrayList<String>(2);
|
|
recipients.add(USER_1);
|
|
recipients.add(USER_2);
|
|
|
|
Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_FROM, "sender@example.com");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO_MANY, recipients);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE_MODEL, (Serializable) getModel());
|
|
|
|
ACTION_EXECUTER.resetTestSentCount();
|
|
|
|
ACTION_SERVICE.executeAction(mailAction, null);
|
|
|
|
MimeMessage message = ACTION_EXECUTER.retrieveLastTestMessage();
|
|
Assert.assertNotNull(message);
|
|
Assert.assertEquals("One email should be sent", 1, ACTION_EXECUTER.getTestSentCount());
|
|
Assert.assertEquals("All recipients should receive single message", 2, message.getAllRecipients().length);
|
|
|
|
Assert.assertTrue("Both users should receive message", recipientsResult.contains(((InternetAddress) message.getAllRecipients()[0]).getAddress()));
|
|
Assert.assertTrue("Both users should receive message", recipientsResult.contains(((InternetAddress) message.getAllRecipients()[1]).getAddress()));
|
|
}
|
|
finally
|
|
{
|
|
// tidy up
|
|
PERSON_SERVICE.deletePerson(USER_1);
|
|
PERSON_SERVICE.deletePerson(USER_2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test for CC / BCC
|
|
* @throws Exception
|
|
*/
|
|
@Test
|
|
public void testSendingToCarbonCopy() throws IOException, MessagingException
|
|
{
|
|
// PARAM_TO variant
|
|
Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_FROM, "some.body@example.com");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO, "some.bodyelse@example.com");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_CC, "some.carbon@example.com");
|
|
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing CARBON COPY");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE, "alfresco/templates/mail/test.txt.ftl");
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE_MODEL, (Serializable) getModel());
|
|
|
|
ACTION_SERVICE.executeAction(mailAction, null);
|
|
|
|
MimeMessage message = ACTION_EXECUTER.retrieveLastTestMessage();
|
|
Assert.assertNotNull(message);
|
|
Address[] all = message.getAllRecipients();
|
|
Address[] ccs = message.getRecipients(RecipientType.CC);
|
|
Assert.assertEquals("recipents too short", 2, all.length);
|
|
Assert.assertEquals("cc too short", 1, ccs.length);
|
|
Assert.assertTrue(ccs[0].toString().contains("some.carbon"));
|
|
}
|
|
|
|
|
|
/**
|
|
* Test for MNT-11079
|
|
*/
|
|
@Test
|
|
public void testSendingToUserWithMailAlikeName() throws IOException, MessagingException
|
|
{
|
|
final String USER_1 = "user1@namelookslikeemail";
|
|
final String USER_1_EMAIL = "user1@trueemail.com";
|
|
|
|
try
|
|
{
|
|
createUser(USER_1, USER_1_EMAIL);
|
|
|
|
Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_FROM, "some.body@example.com");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO_MANY, USER_1);
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE, "alfresco/templates/mail/test.txt.ftl");
|
|
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE_MODEL, (Serializable) getModel());
|
|
|
|
ACTION_SERVICE.executeAction(mailAction, null);
|
|
|
|
MimeMessage message = ACTION_EXECUTER.retrieveLastTestMessage();
|
|
Assert.assertNotNull(message);
|
|
Assert.assertEquals("Hello Jan 1, 1970", (String) message.getContent());
|
|
Assert.assertEquals(1, message.getAllRecipients().length);
|
|
javax.mail.internet.InternetAddress address = (InternetAddress) message.getAllRecipients()[0];
|
|
Assert.assertEquals(USER_1_EMAIL, address.getAddress());
|
|
}
|
|
finally
|
|
{
|
|
// tidy up
|
|
PERSON_SERVICE.deletePerson(USER_1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test for MNT-12464
|
|
* @throws Exception
|
|
*/
|
|
@Test
|
|
public void testMultipleIdenticalEmailsToUser() throws Exception
|
|
{
|
|
final String USER_1 = "user12464_1";
|
|
final String USER_2 = "user12464_2";
|
|
final String USER_3 = "user12464_3";
|
|
final String USER_6 = "user12464_6";
|
|
|
|
final String USER_4_USERNAME = "user12464_4@mnt12464mail.com";
|
|
final String USER_5_USERNAME = "user12464_5@mnt12464mail.com";
|
|
|
|
String[] users = new String[] { USER_1, USER_2, USER_3, USER_4_USERNAME, USER_5_USERNAME };
|
|
|
|
final String GROUP_1_SHORT_NAME = "mnt12464group1";
|
|
final String GROUP_1 = "GROUP_" + GROUP_1_SHORT_NAME;
|
|
final String GROUP_2_SHORT_NAME = "mnt12464group2";
|
|
final String GROUP_2 = "GROUP_" + GROUP_2_SHORT_NAME;
|
|
|
|
try
|
|
{
|
|
createUser(USER_1, null);
|
|
createUser(USER_2, null);
|
|
createUser(USER_3, null);
|
|
AUTHORITY_SERVICE.createAuthority(AuthorityType.GROUP, GROUP_1_SHORT_NAME);
|
|
AUTHORITY_SERVICE.createAuthority(AuthorityType.GROUP, GROUP_2_SHORT_NAME);
|
|
AUTHORITY_SERVICE.addAuthority(GROUP_1, USER_1);
|
|
AUTHORITY_SERVICE.addAuthority(GROUP_1, USER_2);
|
|
AUTHORITY_SERVICE.addAuthority(GROUP_2, USER_1);
|
|
AUTHORITY_SERVICE.addAuthority(GROUP_2, USER_2);
|
|
AUTHORITY_SERVICE.addAuthority(GROUP_2, USER_3);
|
|
|
|
// these persons should be without emails
|
|
PropertyMap personProps = new PropertyMap();
|
|
personProps.put(ContentModel.PROP_USERNAME, USER_4_USERNAME);
|
|
personProps.put(ContentModel.PROP_FIRSTNAME, USER_4_USERNAME);
|
|
personProps.put(ContentModel.PROP_LASTNAME, USER_4_USERNAME);
|
|
PERSON_SERVICE.createPerson(personProps);
|
|
AUTHORITY_SERVICE.addAuthority(GROUP_1, USER_4_USERNAME);
|
|
AUTHORITY_SERVICE.addAuthority(GROUP_2, USER_4_USERNAME);
|
|
|
|
personProps = new PropertyMap();
|
|
personProps.put(ContentModel.PROP_USERNAME, USER_5_USERNAME);
|
|
personProps.put(ContentModel.PROP_FIRSTNAME, USER_5_USERNAME);
|
|
personProps.put(ContentModel.PROP_LASTNAME, USER_5_USERNAME);
|
|
PERSON_SERVICE.createPerson(personProps);
|
|
|
|
Action mailAction1 = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction1.setParameterValue(MailActionExecuter.PARAM_FROM, "some.body@example.com");
|
|
ArrayList<String> toMany1 = new ArrayList<String>();
|
|
toMany1.add(USER_1);
|
|
toMany1.add(GROUP_1);
|
|
toMany1.add(USER_2);
|
|
toMany1.add(GROUP_2);
|
|
toMany1.add(USER_3);
|
|
toMany1.add(USER_4_USERNAME);
|
|
toMany1.add(USER_5_USERNAME);
|
|
mailAction1.setParameterValue(MailActionExecuter.PARAM_TO_MANY, toMany1);
|
|
mailAction1.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing MNT-12464");
|
|
mailAction1.setParameterValue(MailActionExecuter.PARAM_TEMPLATE, "alfresco/templates/mail/test.txt.ftl");
|
|
mailAction1.setParameterValue(MailActionExecuter.PARAM_TEMPLATE_MODEL, (Serializable) getModel());
|
|
|
|
ACTION_EXECUTER.resetTestSentCount();
|
|
ACTION_SERVICE.executeAction(mailAction1, null);
|
|
|
|
Assert.assertEquals("Must be received one letter on each recipient", users.length, ACTION_EXECUTER.getTestSentCount());
|
|
|
|
// testing for GROUP_EVERYONE
|
|
|
|
ACTION_EXECUTER.resetTestSentCount();
|
|
everyoneSending();
|
|
int before = ACTION_EXECUTER.getTestSentCount();
|
|
// create one additional user
|
|
NodeRef user6 = createUser(USER_6, null);
|
|
PERMISSION_SERVICE.setInheritParentPermissions(user6, false);
|
|
PERMISSION_SERVICE.deletePermissions(user6);
|
|
|
|
// USER_6 not exist for USER_1, but he will be added to recipients
|
|
int after = AuthenticationUtil.runAs(new RunAsWork<Integer>()
|
|
{
|
|
@Override
|
|
public Integer doWork() throws Exception
|
|
{
|
|
ACTION_EXECUTER.resetTestSentCount();
|
|
everyoneSending();
|
|
return ACTION_EXECUTER.getTestSentCount();
|
|
}
|
|
}, USER_1);
|
|
|
|
Assert.assertEquals("One additional user was created, quantity of recipients GROUP_EVERYONE must be +1 user", 1, after - before);
|
|
}
|
|
finally
|
|
{
|
|
PERSON_SERVICE.deletePerson(USER_1);
|
|
PERSON_SERVICE.deletePerson(USER_2);
|
|
PERSON_SERVICE.deletePerson(USER_3);
|
|
PERSON_SERVICE.deletePerson(USER_4_USERNAME);
|
|
PERSON_SERVICE.deletePerson(USER_5_USERNAME);
|
|
PERSON_SERVICE.deletePerson(USER_6);
|
|
AUTHORITY_SERVICE.deleteAuthority(GROUP_1);
|
|
AUTHORITY_SERVICE.deleteAuthority(GROUP_2);
|
|
}
|
|
}
|
|
|
|
private void everyoneSending()
|
|
{
|
|
Action mailAction = ACTION_SERVICE.createAction(MailActionExecuter.NAME);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_FROM, "some.body@example.com");
|
|
ArrayList<String> toMany = new ArrayList<String>();
|
|
toMany.add(PERMISSION_SERVICE.getAllAuthorities());
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TO_MANY, toMany);
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_SUBJECT, "Testing MNT-12464");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE, "alfresco/templates/mail/test.txt.ftl");
|
|
mailAction.setParameterValue(MailActionExecuter.PARAM_TEMPLATE_MODEL, (Serializable) getModel());
|
|
|
|
ACTION_EXECUTER.resetTestSentCount();
|
|
|
|
ACTION_SERVICE.executeAction(mailAction, null);
|
|
}
|
|
|
|
/**
|
|
* ACE-2564
|
|
*/
|
|
@Test
|
|
public void testSendEmailByExternalUser() throws IOException, MessagingException
|
|
{
|
|
final Serializable recipients = (Serializable) Arrays.asList(BRITISH_USER.getUsername());
|
|
final String subject = "";
|
|
final String template = "alfresco/templates/mail/test.txt.ftl";
|
|
AuthenticationUtil.pushAuthentication();
|
|
AuthenticationUtil.setFullyAuthenticatedUser(EXTERNAL_USER.getUsername());
|
|
MimeMessage message = null;
|
|
|
|
|
|
try
|
|
{
|
|
|
|
// these persons should be without emails
|
|
|
|
|
|
|
|
|
|
|
|
// testing for GROUP_EVERYONE
|
|
|
|
final String tenantId = getUsersHomeTenant(BRITISH_USER.getUsername());
|
|
|
|
// USER_6 not exist for USER_1, but he will be added to recipients
|
|
message = TenantUtil.runAsTenant(new TenantRunAsWork<MimeMessage>()
|
|
{
|
|
@Override
|
|
public MimeMessage doWork() throws Exception
|
|
{
|
|
return sendMessage(null, recipients, subject, template);
|
|
}
|
|
}, tenantId);
|
|
|
|
Assert.assertNotNull(message);
|
|
Assert.assertEquals("Hello 01-Jan-1970", (String) message.getContent());
|
|
}
|
|
finally
|
|
{
|
|
AuthenticationUtil.popAuthentication();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|