mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-07-07 18:25:23 +00:00
d0fa96a05e
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@22095 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
882 lines
36 KiB
Java
882 lines
36 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.action.scheduled;
|
|
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
|
|
import javax.transaction.UserTransaction;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.repo.action.ActionImpl;
|
|
import org.alfresco.repo.action.RuntimeActionService;
|
|
import org.alfresco.repo.action.ActionServiceImplTest.SleepActionExecuter;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil;
|
|
import org.alfresco.service.cmr.action.Action;
|
|
import org.alfresco.service.cmr.action.ActionService;
|
|
import org.alfresco.service.cmr.action.scheduled.ScheduledPersistedAction;
|
|
import org.alfresco.service.cmr.action.scheduled.ScheduledPersistedActionService;
|
|
import org.alfresco.service.cmr.action.scheduled.SchedulableAction.IntervalPeriod;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
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.quartz.DateIntervalTrigger;
|
|
import org.quartz.Job;
|
|
import org.quartz.JobDetail;
|
|
import org.quartz.JobExecutionContext;
|
|
import org.quartz.JobExecutionException;
|
|
import org.quartz.Scheduler;
|
|
import org.quartz.SimpleTrigger;
|
|
import org.quartz.Trigger;
|
|
import org.quartz.DateIntervalTrigger.IntervalUnit;
|
|
import org.springframework.beans.BeansException;
|
|
import org.springframework.context.ApplicationContext;
|
|
import org.springframework.context.ApplicationContextAware;
|
|
import org.springframework.context.ConfigurableApplicationContext;
|
|
|
|
/**
|
|
* Unit tests for the {@link ScheduledPersistedActionService}
|
|
*/
|
|
public class ScheduledPersistedActionServiceTest extends TestCase
|
|
{
|
|
private static ConfigurableApplicationContext ctx = (ConfigurableApplicationContext) ApplicationContextHelper
|
|
.getApplicationContext();
|
|
|
|
private ScheduledPersistedActionService service;
|
|
private ScheduledPersistedActionServiceImpl serviceImpl;
|
|
private Scheduler scheduler;
|
|
|
|
private TransactionService transactionService;
|
|
private RuntimeActionService runtimeActionService;
|
|
private ActionService actionService;
|
|
private NodeService nodeService;
|
|
|
|
private Action testAction;
|
|
private Action testAction2;
|
|
private Action testAction3;
|
|
|
|
@Override
|
|
protected void setUp() throws Exception
|
|
{
|
|
actionService = (ActionService) ctx.getBean("actionService");
|
|
nodeService = (NodeService) ctx.getBean("nodeService");
|
|
transactionService = (TransactionService) ctx.getBean("transactionService");
|
|
runtimeActionService = (RuntimeActionService) ctx.getBean("actionService");
|
|
service = (ScheduledPersistedActionService) ctx.getBean("ScheduledPersistedActionService");
|
|
serviceImpl = (ScheduledPersistedActionServiceImpl) ctx.getBean("scheduledPersistedActionService");
|
|
scheduler = (Scheduler) ctx.getBean("schedulerFactory");
|
|
|
|
// Set the current security context as admin
|
|
AuthenticationUtil.setFullyAuthenticatedUser(AuthenticationUtil.getAdminUserName());
|
|
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
|
|
// Register the test executor, if needed
|
|
SleepActionExecuter.registerIfNeeded(ctx);
|
|
|
|
// Zap all test schedules
|
|
List<ScheduledPersistedAction> schedules = service.listSchedules();
|
|
for (ScheduledPersistedAction schedule : schedules)
|
|
{
|
|
service.deleteSchedule(schedule);
|
|
}
|
|
|
|
// Persist an action that uses the test executor
|
|
testAction = new TestAction(actionService.createAction(SleepActionExecuter.NAME));
|
|
runtimeActionService.createActionNodeRef(
|
|
//
|
|
testAction, ScheduledPersistedActionServiceImpl.SCHEDULED_ACTION_ROOT_NODE_REF,
|
|
ContentModel.ASSOC_CONTAINS, QName.createQName("TestAction"));
|
|
|
|
testAction2 = new TestAction(actionService.createAction(SleepActionExecuter.NAME));
|
|
runtimeActionService.createActionNodeRef(
|
|
//
|
|
testAction2, ScheduledPersistedActionServiceImpl.SCHEDULED_ACTION_ROOT_NODE_REF,
|
|
ContentModel.ASSOC_CONTAINS, QName.createQName("TestAction2"));
|
|
|
|
testAction3 = new TestAction(actionService.createAction(SleepActionExecuter.NAME));
|
|
|
|
// Finish setup
|
|
txn.commit();
|
|
|
|
// By default, we don't want the scheduler to fire while the tests run
|
|
// Certain tests will enable it as required
|
|
scheduler.standby();
|
|
}
|
|
|
|
@Override
|
|
protected void tearDown() throws Exception
|
|
{
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
|
|
// Zap all test schedules
|
|
List<ScheduledPersistedAction> schedules = service.listSchedules();
|
|
for (ScheduledPersistedAction schedule : schedules)
|
|
{
|
|
service.deleteSchedule(schedule);
|
|
}
|
|
txn.commit();
|
|
|
|
// Re-enable the scheduler again
|
|
scheduler.start();
|
|
}
|
|
|
|
/**
|
|
* Test that the {@link ScheduledPersistedAction} implementation behaves
|
|
* properly
|
|
*/
|
|
public void testPersistedActionImpl() throws Exception
|
|
{
|
|
ScheduledPersistedActionImpl schedule =
|
|
new ScheduledPersistedActionImpl(testAction);
|
|
ScheduledPersistedActionImpl schedule3 =
|
|
new ScheduledPersistedActionImpl(testAction3);
|
|
|
|
|
|
// Check the core bits
|
|
assertEquals(null, schedule.getPersistedAtNodeRef());
|
|
assertEquals(testAction, schedule.getAction());
|
|
assertEquals(testAction.getNodeRef(), schedule.getActionNodeRef());
|
|
|
|
assertEquals(null, schedule3.getPersistedAtNodeRef());
|
|
assertEquals(testAction3, schedule3.getAction());
|
|
assertEquals(null, schedule3.getActionNodeRef());
|
|
|
|
// Persist the 3rd action
|
|
runtimeActionService.createActionNodeRef(
|
|
//
|
|
testAction3, ScheduledPersistedActionServiceImpl.SCHEDULED_ACTION_ROOT_NODE_REF,
|
|
ContentModel.ASSOC_CONTAINS, QName.createQName("TestAction3"));
|
|
|
|
assertEquals(null, schedule.getPersistedAtNodeRef());
|
|
assertEquals(testAction, schedule.getAction());
|
|
assertEquals(testAction.getNodeRef(), schedule.getActionNodeRef());
|
|
|
|
assertEquals(null, schedule3.getPersistedAtNodeRef());
|
|
assertEquals(testAction3, schedule3.getAction());
|
|
assertEquals(testAction3.getNodeRef(), schedule3.getActionNodeRef());
|
|
assertNotNull(schedule3.getAction().getNodeRef());
|
|
|
|
|
|
// Check the start/end date bits
|
|
assertEquals(null, schedule.getScheduleStart());
|
|
assertEquals(null, schedule.getScheduleEnd());
|
|
|
|
schedule.setScheduleStart(new Date(1234));
|
|
assertEquals(1234, schedule.getScheduleStart().getTime());
|
|
assertEquals(null, schedule.getScheduleEnd());
|
|
|
|
schedule.setScheduleEnd(new Date(4321));
|
|
assertEquals(1234, schedule.getScheduleStart().getTime());
|
|
assertEquals(4321, schedule.getScheduleEnd().getTime());
|
|
|
|
assertEquals(null, schedule3.getScheduleStart());
|
|
assertEquals(null, schedule3.getScheduleEnd());
|
|
|
|
schedule.setScheduleStart(null);
|
|
assertEquals(null, schedule.getScheduleStart());
|
|
assertEquals(4321, schedule.getScheduleEnd().getTime());
|
|
|
|
schedule.setScheduleEnd(null);
|
|
assertEquals(null, schedule.getScheduleStart());
|
|
assertEquals(null, schedule.getScheduleEnd());
|
|
|
|
|
|
// Check the interval parts
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(null, schedule.getScheduleIntervalCount());
|
|
assertEquals(null, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalCount(3);
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(3, schedule.getScheduleIntervalCount().intValue());
|
|
assertEquals(null, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
assertEquals("3Hour", schedule.getScheduleInterval());
|
|
assertEquals(3, schedule.getScheduleIntervalCount().intValue());
|
|
assertEquals(IntervalPeriod.Hour, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalCount(8);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Month);
|
|
assertEquals("8Month", schedule.getScheduleInterval());
|
|
assertEquals(8, schedule.getScheduleIntervalCount().intValue());
|
|
assertEquals(IntervalPeriod.Month, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalCount(null);
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(null, schedule.getScheduleIntervalCount());
|
|
assertEquals(IntervalPeriod.Month, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(null, schedule.getScheduleIntervalCount());
|
|
assertEquals(null, schedule.getScheduleIntervalPeriod());
|
|
|
|
// Trigger parts happen in another test
|
|
}
|
|
|
|
/**
|
|
* Tests that the to-trigger stuff works properly
|
|
*/
|
|
public void testActionToTrigger() throws Exception
|
|
{
|
|
// Can't get a trigger until persisted
|
|
ScheduledPersistedActionImpl schedule =
|
|
(ScheduledPersistedActionImpl)service.createSchedule(testAction);
|
|
Trigger t;
|
|
try {
|
|
schedule.asTrigger();
|
|
fail("Should require persistence first");
|
|
} catch(IllegalStateException e) {}
|
|
|
|
service.saveSchedule(schedule);
|
|
schedule.asTrigger();
|
|
|
|
|
|
// No schedule, no trigger
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(null, schedule.getScheduleIntervalCount());
|
|
assertEquals(null, schedule.getScheduleIntervalPeriod());
|
|
assertEquals(null, schedule.asTrigger());
|
|
|
|
|
|
// Only start date
|
|
schedule.setScheduleStart(new Date(12345));
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals(12345, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
assertEquals(SimpleTrigger.class, t.getClass());
|
|
|
|
|
|
// Only end date
|
|
// (End date + no repeat = never schedule)
|
|
schedule.setScheduleStart(null);
|
|
schedule.setScheduleEnd(new Date(12345));
|
|
|
|
t = schedule.asTrigger();
|
|
assertEquals(null, t);
|
|
|
|
|
|
// Only interval
|
|
schedule.setScheduleStart(null);
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleIntervalCount(2);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Second);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals((double)System.currentTimeMillis(), (double)t.getStartTime().getTime(), 5); // Within 5ms
|
|
assertEquals(null, t.getEndTime());
|
|
assertEquals(DateIntervalTrigger.class, t.getClass());
|
|
assertEquals(2, ((DateIntervalTrigger)t).getRepeatInterval());
|
|
assertEquals(IntervalUnit.SECOND, ((DateIntervalTrigger)t).getRepeatIntervalUnit());
|
|
|
|
|
|
// Start+interval
|
|
schedule.setScheduleStart(new Date(12345));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleIntervalCount(3);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Month);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals(12345, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
assertEquals(DateIntervalTrigger.class, t.getClass());
|
|
assertEquals(3, ((DateIntervalTrigger)t).getRepeatInterval());
|
|
assertEquals(IntervalUnit.MONTH, ((DateIntervalTrigger)t).getRepeatIntervalUnit());
|
|
|
|
|
|
// Start+interval+end
|
|
schedule.setScheduleStart(new Date(12345));
|
|
schedule.setScheduleEnd(new Date(54321));
|
|
schedule.setScheduleIntervalCount(12);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Week);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals(12345, t.getStartTime().getTime());
|
|
assertEquals(54321, t.getEndTime().getTime());
|
|
assertEquals(DateIntervalTrigger.class, t.getClass());
|
|
assertEquals(12, ((DateIntervalTrigger)t).getRepeatInterval());
|
|
assertEquals(IntervalUnit.WEEK, ((DateIntervalTrigger)t).getRepeatIntervalUnit());
|
|
|
|
|
|
// interval+end
|
|
long future = System.currentTimeMillis() + 1234567;
|
|
schedule.setScheduleStart(null);
|
|
schedule.setScheduleEnd(new Date(future));
|
|
schedule.setScheduleIntervalCount(6);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals((double)System.currentTimeMillis(), (double)t.getStartTime().getTime(), 2); // Within 2ms
|
|
assertEquals(future, t.getEndTime().getTime());
|
|
assertEquals(DateIntervalTrigger.class, t.getClass());
|
|
assertEquals(6, ((DateIntervalTrigger)t).getRepeatInterval());
|
|
assertEquals(IntervalUnit.HOUR, ((DateIntervalTrigger)t).getRepeatIntervalUnit());
|
|
|
|
|
|
// Start+end
|
|
// (The end bit is ignored, as there's no interval to decide over)
|
|
schedule.setScheduleStart(new Date(12345));
|
|
schedule.setScheduleEnd(new Date(54321));
|
|
schedule.setScheduleIntervalCount(null);
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals(12345, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
assertEquals(SimpleTrigger.class, t.getClass());
|
|
}
|
|
|
|
/**
|
|
* Tests that we can create, save, edit, delete etc the scheduled persisted
|
|
* actions
|
|
*/
|
|
public void testCreation()
|
|
{
|
|
ScheduledPersistedAction schedule = service.createSchedule(testAction);
|
|
assertNotNull(schedule);
|
|
assertTrue(testAction == schedule.getAction());
|
|
assertEquals(testAction.getNodeRef(), schedule.getAction().getNodeRef());
|
|
|
|
assertNull(schedule.getScheduleStart());
|
|
assertNull(schedule.getScheduleInterval());
|
|
assertNull(schedule.getScheduleIntervalCount());
|
|
assertNull(schedule.getScheduleIntervalPeriod());
|
|
|
|
Date now = new Date();
|
|
schedule.setScheduleStart(now);
|
|
assertEquals(now, schedule.getScheduleStart());
|
|
schedule.setScheduleIntervalCount(2);
|
|
assertEquals(new Integer(2), schedule.getScheduleIntervalCount());
|
|
schedule.setScheduleIntervalPeriod(ScheduledPersistedAction.IntervalPeriod.Day);
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, schedule.getScheduleIntervalPeriod());
|
|
}
|
|
|
|
public void testCreateSaveLoad() throws Exception
|
|
{
|
|
// create and save schedule
|
|
ScheduledPersistedAction schedule = service.createSchedule(testAction);
|
|
assertNotNull(schedule);
|
|
Date now = new Date();
|
|
schedule.setScheduleStart(now);
|
|
schedule.setScheduleIntervalCount(2);
|
|
schedule.setScheduleIntervalPeriod(ScheduledPersistedAction.IntervalPeriod.Day);
|
|
|
|
assertNull( ((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef() );
|
|
service.saveSchedule(schedule);
|
|
assertNotNull( ((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef() );
|
|
|
|
// Load it again, should have the same details still
|
|
ScheduledPersistedAction retrieved = serviceImpl.loadPersistentSchedule(((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef());
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(2), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, retrieved.getScheduleIntervalPeriod());
|
|
assertNotNull( ((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef() );
|
|
|
|
// Load a 2nd copy, won't be any changes
|
|
ScheduledPersistedAction second = serviceImpl.loadPersistentSchedule(((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef());
|
|
assertNotNull(second);
|
|
assertEquals(testAction.getNodeRef(), second.getAction().getNodeRef());
|
|
assertEquals(now, second.getScheduleStart());
|
|
assertEquals(new Integer(2), second.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, second.getScheduleIntervalPeriod());
|
|
|
|
|
|
// Now ensure we can create for an action that didn't have a noderef
|
|
// when we started
|
|
schedule = service.createSchedule(testAction3);
|
|
|
|
assertNull(schedule.getActionNodeRef());
|
|
assertNull( ((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef() );
|
|
|
|
runtimeActionService.createActionNodeRef(
|
|
//
|
|
testAction3, ScheduledPersistedActionServiceImpl.SCHEDULED_ACTION_ROOT_NODE_REF,
|
|
ContentModel.ASSOC_CONTAINS, QName.createQName("TestAction3"));
|
|
|
|
assertNotNull(schedule.getActionNodeRef());
|
|
assertNull( ((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef() );
|
|
|
|
service.saveSchedule(schedule);
|
|
|
|
assertNotNull(schedule.getActionNodeRef());
|
|
assertNotNull( ((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef() );
|
|
}
|
|
|
|
/**
|
|
* Ensures that we can create, save, edit, save
|
|
* load, edit, save, load etc, all without
|
|
* problems, and without creating duplicates
|
|
*/
|
|
public void testEditing() throws Exception
|
|
{
|
|
// create and save schedule
|
|
ScheduledPersistedAction schedule = service.createSchedule(testAction);
|
|
assertNotNull(schedule);
|
|
Date now = new Date();
|
|
schedule.setScheduleStart(now);
|
|
schedule.setScheduleIntervalCount(2);
|
|
schedule.setScheduleIntervalPeriod(ScheduledPersistedAction.IntervalPeriod.Day);
|
|
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
service.saveSchedule(schedule);
|
|
txn.commit();
|
|
|
|
// Load and check it hasn't changed
|
|
txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
ScheduledPersistedAction retrieved = serviceImpl.loadPersistentSchedule(((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef());
|
|
txn.commit();
|
|
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(2), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, retrieved.getScheduleIntervalPeriod());
|
|
|
|
// Save and re-load without changes
|
|
txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
service.saveSchedule(schedule);
|
|
retrieved = serviceImpl.loadPersistentSchedule(((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef());
|
|
txn.commit();
|
|
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(2), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, retrieved.getScheduleIntervalPeriod());
|
|
|
|
// Make some small changes
|
|
txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
retrieved = serviceImpl.loadPersistentSchedule(((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef());
|
|
retrieved.setScheduleIntervalCount(3);
|
|
service.saveSchedule(retrieved);
|
|
retrieved = serviceImpl.loadPersistentSchedule(((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef());
|
|
txn.commit();
|
|
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(3), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, retrieved.getScheduleIntervalPeriod());
|
|
|
|
// And some more changes
|
|
retrieved.setScheduleIntervalPeriod(ScheduledPersistedAction.IntervalPeriod.Month);
|
|
now = new Date();
|
|
retrieved.setScheduleStart(now);
|
|
|
|
txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
service.saveSchedule(retrieved);
|
|
retrieved = serviceImpl.loadPersistentSchedule(((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef());
|
|
txn.commit();
|
|
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(3), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Month, retrieved.getScheduleIntervalPeriod());
|
|
}
|
|
|
|
/**
|
|
* Tests that the listings work, both of all scheduled, and from an action
|
|
*/
|
|
public void testLoadList() throws Exception
|
|
{
|
|
assertEquals(0, service.listSchedules().size());
|
|
|
|
// Create
|
|
ScheduledPersistedAction schedule1 = service.createSchedule(testAction);
|
|
assertNotNull(schedule1);
|
|
ScheduledPersistedAction schedule2 = service.createSchedule(testAction2);
|
|
assertNotNull(schedule2);
|
|
|
|
assertEquals(0, service.listSchedules().size());
|
|
|
|
service.saveSchedule(schedule1);
|
|
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(testAction.getNodeRef(), service.listSchedules().get(0).getActionNodeRef());
|
|
|
|
service.saveSchedule(schedule2);
|
|
assertEquals(2, service.listSchedules().size());
|
|
}
|
|
|
|
public void testLoadFromAction() throws Exception
|
|
{
|
|
// Create schedule
|
|
ScheduledPersistedAction schedule1 = service.createSchedule(testAction);
|
|
assertNotNull(schedule1);
|
|
service.saveSchedule(schedule1);
|
|
|
|
// retrieve schedule for action which doesn't have schedule
|
|
ScheduledPersistedAction retrieved = service.getSchedule(testAction2);
|
|
assertNull(retrieved);
|
|
|
|
// and from one which does
|
|
retrieved = service.getSchedule(testAction);
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getActionNodeRef());
|
|
}
|
|
|
|
/**
|
|
* Tests that the startup registering works properly
|
|
*/
|
|
public void testStartup() throws Exception
|
|
{
|
|
// Startup with none there, nothing happens
|
|
// TODO
|
|
|
|
// Add one manually, startup, see it is registered
|
|
// TODO
|
|
|
|
|
|
// ====================================
|
|
// Startup related re-scheduling parts
|
|
// ====================================
|
|
|
|
// No start date, repeats set, never run
|
|
// TODO
|
|
|
|
// No start date, repeats set, previously run
|
|
// TODO
|
|
|
|
// Start date, no repeats, never run
|
|
// TODO
|
|
|
|
// Start date, no repeats, previously run
|
|
// TODO
|
|
|
|
// Start date, has repeats, never run
|
|
// TODO
|
|
|
|
// Start date, has repeats, previously run
|
|
// TODO
|
|
}
|
|
|
|
/**
|
|
* Ensures that deletion works correctly
|
|
*/
|
|
public void testDeletion() throws Exception
|
|
{
|
|
// Delete does nothing if not persisted
|
|
assertEquals(0, service.listSchedules().size());
|
|
ScheduledPersistedAction schedule1 = service.createSchedule(testAction);
|
|
assertEquals(0, service.listSchedules().size());
|
|
|
|
service.deleteSchedule(schedule1);
|
|
assertEquals(0, service.listSchedules().size());
|
|
|
|
// Create and save two
|
|
ScheduledPersistedAction schedule2 = service.createSchedule(testAction2);
|
|
service.saveSchedule(schedule1);
|
|
service.saveSchedule(schedule2);
|
|
assertEquals(2, service.listSchedules().size());
|
|
NodeRef schedule1NodeRef = ((ScheduledPersistedActionImpl)schedule1).getPersistedAtNodeRef();
|
|
NodeRef schedule2NodeRef = ((ScheduledPersistedActionImpl)schedule2).getPersistedAtNodeRef();
|
|
|
|
// Both should have the relationship
|
|
assertEquals(1, nodeService.getTargetAssocs(schedule1NodeRef, RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(1, nodeService.getTargetAssocs(schedule2NodeRef, RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(1, nodeService.getSourceAssocs(testAction.getNodeRef(), RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(1, nodeService.getSourceAssocs(testAction2.getNodeRef(), RegexQNamePattern.MATCH_ALL).size());
|
|
|
|
// Delete one - the correct one goes!
|
|
service.deleteSchedule(schedule2);
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(testAction.getNodeRef(), service.listSchedules().get(0).getActionNodeRef());
|
|
assertNotNull(serviceImpl.loadPersistentSchedule(schedule1NodeRef));
|
|
assertNull(serviceImpl.loadPersistentSchedule(schedule2NodeRef));
|
|
assertNotNull(service.getSchedule(testAction));
|
|
assertNull(service.getSchedule(testAction2));
|
|
|
|
// Ensure that the relationship went
|
|
assertEquals(1, nodeService.getTargetAssocs(schedule1NodeRef, RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(1, nodeService.getSourceAssocs(testAction.getNodeRef(), RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(0, nodeService.getSourceAssocs(testAction2.getNodeRef(), RegexQNamePattern.MATCH_ALL).size());
|
|
|
|
// Re-delete already deleted, no change
|
|
service.deleteSchedule(schedule2);
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(testAction.getNodeRef(), service.listSchedules().get(0).getActionNodeRef());
|
|
assertNotNull(serviceImpl.loadPersistentSchedule(schedule1NodeRef));
|
|
assertNull(serviceImpl.loadPersistentSchedule(schedule2NodeRef));
|
|
assertNotNull(service.getSchedule(testAction));
|
|
assertNull(service.getSchedule(testAction2));
|
|
|
|
// Delete the 2nd
|
|
service.deleteSchedule(schedule1);
|
|
assertEquals(0, service.listSchedules().size());
|
|
assertNull(serviceImpl.loadPersistentSchedule(schedule1NodeRef));
|
|
assertNull(serviceImpl.loadPersistentSchedule(schedule2NodeRef));
|
|
assertNull(service.getSchedule(testAction));
|
|
assertNull(service.getSchedule(testAction2));
|
|
|
|
// Ensure that the relationship went
|
|
assertEquals(0, nodeService.getSourceAssocs(testAction.getNodeRef(), RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(0, nodeService.getSourceAssocs(testAction2.getNodeRef(), RegexQNamePattern.MATCH_ALL).size());
|
|
|
|
// Can add back in again after being deleted
|
|
service.saveSchedule(schedule1);
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(testAction.getNodeRef(), service.listSchedules().get(0).getActionNodeRef());
|
|
assertNotNull(service.getSchedule(testAction));
|
|
assertNull(service.getSchedule(testAction2));
|
|
|
|
// If we delete the action, then we have an orphaned schedule
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
nodeService.deleteNode(testAction.getNodeRef());
|
|
txn.commit();
|
|
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(null, service.listSchedules().get(0).getAction());
|
|
assertEquals(null, service.listSchedules().get(0).getActionNodeRef());
|
|
}
|
|
|
|
/**
|
|
* Tests that things get properly injected onto the job bean
|
|
*/
|
|
public void testJobBeanInjection() throws Exception
|
|
{
|
|
// This test needs the scheduler running properly
|
|
scheduler.start();
|
|
|
|
// The job should run almost immediately
|
|
Job job = new TestJob();
|
|
JobDetail details = new JobDetail("ThisIsATest", null, job.getClass());
|
|
Trigger now = new SimpleTrigger("TestTrigger", new Date(1));
|
|
now.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
|
|
|
|
Scheduler scheduler = (Scheduler) ctx.getBean("schedulerFactory");
|
|
scheduler.scheduleJob(details, now);
|
|
|
|
// Allow it to run
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
if (!TestJob.ran)
|
|
Thread.sleep(50);
|
|
}
|
|
|
|
// Ensure it ran, and it got a copy of the context
|
|
assertEquals(true, TestJob.ran);
|
|
assertEquals(true, TestJob.gotContext);
|
|
}
|
|
|
|
/**
|
|
* Tests that things actually get run correctly
|
|
*/
|
|
public void testExecution() throws Exception
|
|
{
|
|
final SleepActionExecuter sleepActionExec = (SleepActionExecuter) ctx.getBean(SleepActionExecuter.NAME);
|
|
sleepActionExec.resetTimesExecuted();
|
|
sleepActionExec.setSleepMs(1);
|
|
|
|
ScheduledPersistedAction schedule;
|
|
|
|
// This test needs the scheduler running properly
|
|
scheduler.start();
|
|
|
|
// Until the schedule is persisted, nothing will happen
|
|
schedule = service.createSchedule(testAction);
|
|
assertEquals(0, scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
// A job due to start in 1 second, and run once
|
|
schedule = service.createSchedule(testAction);
|
|
schedule.setScheduleStart(new Date(System.currentTimeMillis() + 1000));
|
|
assertNull(schedule.getScheduleInterval());
|
|
assertNull(schedule.getScheduleIntervalCount());
|
|
assertNull(schedule.getScheduleIntervalPeriod());
|
|
assertNull(schedule.getScheduleLastExecutedAt());
|
|
|
|
System.out.println("Job starts in 1 second, no repeat...");
|
|
service.saveSchedule(schedule);
|
|
|
|
// Check it went in
|
|
assertEquals(1, scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
// Let it run
|
|
Thread.sleep(2000);
|
|
|
|
// Ensure it did properly run the once
|
|
assertEquals(1, sleepActionExec.getTimesExecuted());
|
|
|
|
// Should have removed itself now the schedule is over
|
|
assertEquals(0, scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
// Ensure it was tagged with when it ran
|
|
schedule = service.getSchedule(testAction);
|
|
assertEquals((double)System.currentTimeMillis(), (double)schedule.getScheduleLastExecutedAt().getTime(), 2500); // Within 2.5 secs
|
|
|
|
// Zap it
|
|
service.deleteSchedule(schedule);
|
|
assertEquals(0, scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
// ==========================
|
|
|
|
// A job that runs every 2 seconds, for the next 3.5 seconds
|
|
// (Should get to run twice, now and @2 secs)
|
|
schedule = service.createSchedule(testAction);
|
|
schedule.setScheduleStart(new Date(0));
|
|
((ScheduledPersistedActionImpl) schedule).setScheduleEnd(new Date(System.currentTimeMillis() + 3500));
|
|
schedule.setScheduleIntervalCount(2);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Second);
|
|
assertEquals("2Second", schedule.getScheduleInterval());
|
|
|
|
// Reset count
|
|
sleepActionExec.resetTimesExecuted();
|
|
assertEquals(0, sleepActionExec.getTimesExecuted());
|
|
|
|
System.out.println("Job starts now, repeats twice @ 2s");
|
|
service.saveSchedule(schedule);
|
|
|
|
Thread.sleep(4200);
|
|
|
|
// Ensure it did properly run two times
|
|
// (Depending on timing of tests, might actually slip in 3 runs)
|
|
if(sleepActionExec.getTimesExecuted() == 3) {
|
|
assertEquals(3, sleepActionExec.getTimesExecuted());
|
|
} else {
|
|
assertEquals(2, sleepActionExec.getTimesExecuted());
|
|
}
|
|
|
|
// Zap it
|
|
service.deleteSchedule(schedule);
|
|
assertEquals(0, scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
// ==========================
|
|
|
|
// A job that starts in 2 seconds time, and runs
|
|
// every second until we kill it
|
|
schedule = service.createSchedule(testAction);
|
|
schedule.setScheduleStart(new Date(System.currentTimeMillis() + 2000));
|
|
schedule.setScheduleIntervalCount(1);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Second);
|
|
assertEquals("1Second", schedule.getScheduleInterval());
|
|
|
|
// Reset count
|
|
sleepActionExec.resetTimesExecuted();
|
|
assertEquals(0, sleepActionExec.getTimesExecuted());
|
|
|
|
System.out.println("Job starts in 2s, repeats @ 1s");
|
|
service.saveSchedule(schedule);
|
|
|
|
// Let it run a few times
|
|
Thread.sleep(5000);
|
|
|
|
// Zap it - should still be live
|
|
assertEquals(1, scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
service.deleteSchedule(schedule);
|
|
assertEquals(0, scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
// Check it ran an appropriate number of times
|
|
assertEquals("Didn't run enough - " + sleepActionExec.getTimesExecuted(), true, sleepActionExec
|
|
.getTimesExecuted() >= 3);
|
|
assertEquals("Ran too much - " + sleepActionExec.getTimesExecuted(), true,
|
|
sleepActionExec.getTimesExecuted() < 5);
|
|
|
|
// Ensure it finished shutting down
|
|
Thread.sleep(500);
|
|
}
|
|
|
|
/**
|
|
* Tests that when we have more than one schedule defined and active, then
|
|
* the correct things run at the correct times, and we never get confused
|
|
*/
|
|
public void DISABLEDtestMultipleExecutions() throws Exception
|
|
{
|
|
// This test needs the scheduler running properly
|
|
scheduler.start();
|
|
|
|
// Create one that starts running in 2 seconds, runs every 2 seconds
|
|
// until 9 seconds are up (will run 4 times)
|
|
// TODO
|
|
|
|
// Create one that starts running now, every second until 9.5 seconds
|
|
// are up (will run 9-10 times)
|
|
// TODO
|
|
|
|
// Set them going
|
|
// TODO
|
|
|
|
// Wait
|
|
// TODO
|
|
|
|
// Check that they really did run properly
|
|
// TODO
|
|
}
|
|
|
|
// ============================================================================
|
|
|
|
/**
|
|
* For unit testing only - not thread safe!
|
|
*/
|
|
public static class TestJob implements Job, ApplicationContextAware
|
|
{
|
|
private static boolean gotContext = false;
|
|
private static boolean ran = false;
|
|
|
|
public TestJob()
|
|
{
|
|
gotContext = false;
|
|
ran = false;
|
|
}
|
|
|
|
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
|
|
{
|
|
gotContext = true;
|
|
}
|
|
|
|
public void execute(JobExecutionContext paramJobExecutionContext) throws JobExecutionException
|
|
{
|
|
ran = true;
|
|
}
|
|
}
|
|
|
|
protected static class TestAction extends ActionImpl
|
|
{
|
|
protected TestAction(Action action)
|
|
{
|
|
super(action);
|
|
}
|
|
}
|
|
|
|
}
|