001: /*
002: * Copyright 2001-2007 Geert Bevin <gbevin[remove] at uwyn dot com>
003: * Distributed under the terms of either:
004: * - the common development and distribution license (CDDL), v1.0; or
005: * - the GNU Lesser General Public License, v2.1 or later
006: * $Id: TestDatabaseTasks.java 3634 2007-01-08 21:42:24Z gbevin $
007: */
008: package com.uwyn.rife.scheduler.taskmanagers;
009:
010: import java.util.Calendar;
011: import java.util.Collection;
012:
013: import junit.framework.TestCase;
014:
015: import com.uwyn.rife.database.Datasource;
016: import com.uwyn.rife.scheduler.Task;
017: import com.uwyn.rife.scheduler.TaskManager;
018: import com.uwyn.rife.scheduler.TestTasktypes;
019: import com.uwyn.rife.scheduler.exceptions.FrequencyException;
020: import com.uwyn.rife.scheduler.exceptions.SchedulerManagerException;
021: import com.uwyn.rife.scheduler.exceptions.TaskManagerException;
022: import com.uwyn.rife.scheduler.schedulermanagers.DatabaseScheduler;
023: import com.uwyn.rife.scheduler.schedulermanagers.DatabaseSchedulerFactory;
024: import com.uwyn.rife.tools.ExceptionUtils;
025:
026: public class TestDatabaseTasks extends TestCase {
027: private Datasource mDatasource = null;
028:
029: public TestDatabaseTasks(Datasource datasource,
030: String datasourceName, String name) {
031: super (name);
032: mDatasource = datasource;
033: }
034:
035: protected void setUp() throws Exception {
036: DatabaseScheduler schedulermanager = DatabaseSchedulerFactory
037: .getInstance(mDatasource);
038: try {
039: schedulermanager.install();
040: } catch (SchedulerManagerException e) {
041: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
042: }
043: }
044:
045: protected void tearDown() throws Exception {
046: DatabaseScheduler schedulermanager = DatabaseSchedulerFactory
047: .getInstance(mDatasource);
048: try {
049: schedulermanager.remove();
050: } catch (SchedulerManagerException e) {
051: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
052: }
053: }
054:
055: public void testInstantiateTaskManager() {
056: TaskManager manager = DatabaseTasksFactory
057: .getInstance(mDatasource);
058: assertNotNull(manager);
059: }
060:
061: public void testAddTask() {
062: int task_id = -1;
063:
064: String type = TestTasktypes.UPLOAD_GROUPS;
065: Calendar cal = Calendar.getInstance();
066: cal.set(2001, 10, 24, 0, 0, 0);
067: long planned = cal.getTime().getTime();
068: String frequency = "* * * * *";
069: boolean busy = false;
070:
071: Task task = new Task();
072: TaskManager manager = DatabaseTasksFactory
073: .getInstance(mDatasource);
074: try {
075: task.setType(type);
076: task.setPlanned(planned);
077: task.setFrequency(frequency);
078: task.setBusy(busy);
079:
080: task_id = manager.addTask(task);
081: assertTrue(task_id >= 0);
082: } catch (FrequencyException e) {
083: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
084: } catch (TaskManagerException e) {
085: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
086: }
087: }
088:
089: public void testGetTask() {
090: int task_id = -1;
091:
092: String type = TestTasktypes.UPLOAD_GROUPS;
093: Calendar cal = Calendar.getInstance();
094: cal.set(2001, 10, 24, 0, 0, 0);
095: long planned = cal.getTime().getTime();
096: String frequency = "* * * * *";
097: boolean busy = false;
098:
099: Task task = new Task();
100: TaskManager manager = DatabaseTasksFactory
101: .getInstance(mDatasource);
102: try {
103: task.setType(type);
104: task.setPlanned(planned);
105: task.setFrequency(frequency);
106: task.setBusy(busy);
107:
108: task_id = manager.addTask(task);
109: task = manager.getTask(task_id);
110: assertNotNull(task);
111:
112: assertEquals(task.getId(), task_id);
113: assertEquals(task.getType(), TestTasktypes.UPLOAD_GROUPS);
114: assertTrue(task.getPlanned() <= cal.getTime().getTime());
115: assertEquals(task.getFrequency(), "* * * * *");
116: assertEquals(task.isBusy(), false);
117: assertSame(task.getTaskManager(), manager);
118: } catch (FrequencyException e) {
119: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
120: } catch (TaskManagerException e) {
121: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
122: }
123: }
124:
125: public void testUpdateTask() {
126: int task_id = -1;
127:
128: String type = TestTasktypes.UPLOAD_GROUPS;
129: Calendar cal = Calendar.getInstance();
130: cal.set(2001, 10, 24, 0, 0, 0);
131: long planned = cal.getTime().getTime();
132: String frequency = "* * * * *";
133: boolean busy = false;
134:
135: Task task = new Task();
136: TaskManager manager = DatabaseTasksFactory
137: .getInstance(mDatasource);
138: try {
139: task.setType(type);
140: task.setPlanned(planned);
141: task.setFrequency(frequency);
142: task.setBusy(busy);
143:
144: task_id = manager.addTask(task);
145:
146: type = TestTasktypes.SEND_RANKING;
147: cal.set(2002, 02, 12, 0, 0, 0);
148: planned = cal.getTime().getTime();
149: frequency = "*/10 * * * *";
150: busy = true;
151:
152: task = new Task();
153: task.setId(task_id);
154: task.setType(type);
155: task.setPlanned(planned);
156: task.setFrequency(frequency);
157: task.setBusy(busy);
158:
159: assertTrue(true == manager.updateTask(task));
160:
161: task = manager.getTask(task_id);
162: assertNotNull(task);
163:
164: assertEquals(task.getId(), task_id);
165: assertEquals(task.getType(), type);
166: assertTrue(task.getPlanned() <= planned);
167: assertEquals(task.getFrequency(), frequency);
168: assertEquals(task.isBusy(), busy);
169: assertSame(task.getTaskManager(), manager);
170: } catch (FrequencyException e) {
171: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
172: } catch (TaskManagerException e) {
173: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
174: }
175: }
176:
177: public void testRemoveTask() {
178: int task_id = -1;
179:
180: String type = TestTasktypes.UPLOAD_GROUPS;
181: Calendar cal = Calendar.getInstance();
182: cal.set(2001, 10, 24, 0, 0, 0);
183: long planned = cal.getTime().getTime();
184: String frequency = "* * * * *";
185: boolean busy = false;
186:
187: Task task = new Task();
188: TaskManager manager = DatabaseTasksFactory
189: .getInstance(mDatasource);
190: try {
191: task.setType(type);
192: task.setPlanned(planned);
193: task.setFrequency(frequency);
194: task.setBusy(busy);
195:
196: task_id = manager.addTask(task);
197: assertTrue(manager.removeTask(task_id));
198: } catch (FrequencyException e) {
199: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
200: } catch (TaskManagerException e) {
201: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
202: }
203: }
204:
205: public void testGetNonExistingTask() {
206: TaskManager manager = DatabaseTasksFactory
207: .getInstance(mDatasource);
208: int task_nonexisting_id = 0;
209: try {
210: assertNull(manager.getTask(task_nonexisting_id));
211: } catch (TaskManagerException e) {
212: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
213: }
214: }
215:
216: public void testRemoveNonExistingTask() {
217: TaskManager manager = DatabaseTasksFactory
218: .getInstance(mDatasource);
219: int task_nonexisting_id = 0;
220: try {
221: assertTrue(false == manager.removeTask(task_nonexisting_id));
222: } catch (TaskManagerException e) {
223: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
224: }
225: }
226:
227: public void testGetTasksToProcess() {
228: int one_hour = 1000 * 60 * 60;
229:
230: TaskManager manager = DatabaseTasksFactory
231: .getInstance(mDatasource);
232: try {
233: Task task1 = new Task();
234: task1.setType(TestTasktypes.UPLOAD_GROUPS);
235: task1.setPlanned(System.currentTimeMillis() - one_hour);
236: task1.setFrequency(null);
237: task1.setBusy(false);
238:
239: Task task2 = new Task();
240: task2.setType(TestTasktypes.UPLOAD_GROUPS);
241: task2.setPlanned(System.currentTimeMillis() - one_hour);
242: task2.setFrequency(null);
243: task2.setBusy(false);
244:
245: Task task3 = new Task();
246: task3.setType(TestTasktypes.UPLOAD_GROUPS);
247: task3.setPlanned(System.currentTimeMillis() - one_hour);
248: task3.setFrequency(null);
249: task3.setBusy(true);
250:
251: Task task4 = new Task();
252: task4.setType(TestTasktypes.UPLOAD_GROUPS);
253: task4.setPlanned(System.currentTimeMillis() + one_hour);
254: task4.setFrequency(null);
255: task4.setBusy(false);
256:
257: task1.setId(manager.addTask(task1));
258: task2.setId(manager.addTask(task2));
259: task3.setId(manager.addTask(task3));
260: task4.setId(manager.addTask(task4));
261:
262: Collection<Task> tasks_to_process = manager
263: .getTasksToProcess();
264:
265: manager.removeTask(task1.getId());
266: manager.removeTask(task2.getId());
267: manager.removeTask(task3.getId());
268: manager.removeTask(task4.getId());
269:
270: assertEquals(2, tasks_to_process.size());
271: } catch (FrequencyException e) {
272: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
273: } catch (TaskManagerException e) {
274: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
275: }
276: }
277:
278: public void testGetScheduledTasks() {
279: int one_hour = 1000 * 60 * 60;
280:
281: TaskManager manager = DatabaseTasksFactory
282: .getInstance(mDatasource);
283: try {
284: Task task1 = new Task();
285: task1.setType(TestTasktypes.UPLOAD_GROUPS);
286: task1.setPlanned(System.currentTimeMillis() - one_hour);
287: task1.setFrequency(null);
288: task1.setBusy(false);
289:
290: Task task2 = new Task();
291: task2.setType(TestTasktypes.UPLOAD_GROUPS);
292: task2.setPlanned(System.currentTimeMillis() + one_hour);
293: task2.setFrequency(null);
294: task2.setBusy(true);
295:
296: Task task3 = new Task();
297: task3.setType(TestTasktypes.UPLOAD_GROUPS);
298: task3.setPlanned(System.currentTimeMillis() + one_hour);
299: task3.setFrequency(null);
300: task3.setBusy(false);
301:
302: Task task4 = new Task();
303: task4.setType(TestTasktypes.UPLOAD_GROUPS);
304: task4.setPlanned(System.currentTimeMillis() + one_hour);
305: task4.setFrequency(null);
306: task4.setBusy(false);
307:
308: task1.setId(manager.addTask(task1));
309: task2.setId(manager.addTask(task2));
310: task3.setId(manager.addTask(task3));
311: task4.setId(manager.addTask(task4));
312:
313: Collection<Task> scheduled_tasks = manager
314: .getScheduledTasks();
315:
316: manager.removeTask(task1.getId());
317: manager.removeTask(task2.getId());
318: manager.removeTask(task3.getId());
319: manager.removeTask(task4.getId());
320:
321: assertEquals(2, scheduled_tasks.size());
322: } catch (FrequencyException e) {
323: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
324: } catch (TaskManagerException e) {
325: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
326: }
327: }
328:
329: public void testTaskConclusion() {
330: int one_hour = 1000 * 60 * 60;
331:
332: TaskManager manager = DatabaseTasksFactory
333: .getInstance(mDatasource);
334: try {
335: Task task1 = new Task();
336: task1.setType(TestTasktypes.UPLOAD_GROUPS);
337: task1.setPlanned(System.currentTimeMillis() - one_hour);
338: task1.setFrequency(null);
339: task1.setBusy(false);
340:
341: Task task2 = new Task();
342: task2.setType(TestTasktypes.UPLOAD_GROUPS);
343: task2.setPlanned(System.currentTimeMillis() - one_hour);
344: task2.setFrequency("0 * * * *");
345: task2.setBusy(false);
346:
347: Task task3 = new Task();
348: task3.setType(TestTasktypes.UPLOAD_GROUPS);
349: task3.setPlanned(System.currentTimeMillis() + one_hour);
350: task3.setFrequency(null);
351: task3.setBusy(false);
352:
353: task1.setId(manager.addTask(task1));
354: task2.setId(manager.addTask(task2));
355: task3.setId(manager.addTask(task3));
356: task1 = manager.getTask(task1.getId());
357: task2 = manager.getTask(task2.getId());
358: task3 = manager.getTask(task3.getId());
359:
360: boolean was_task1_concluded = manager.concludeTask(task1);
361: boolean was_task2_concluded = manager.concludeTask(task2);
362: boolean was_task3_concluded = manager.concludeTask(task3);
363:
364: Task task1_new = manager.getTask(task1.getId());
365: Task task2_new = manager.getTask(task2.getId());
366: Task task3_new = manager.getTask(task3.getId());
367:
368: manager.removeTask(task2.getId());
369: manager.removeTask(task3.getId());
370:
371: assertTrue(was_task1_concluded);
372: assertTrue(was_task2_concluded);
373: assertTrue(false == was_task3_concluded);
374: assertNull(task1_new);
375: assertNotNull(task2_new);
376: assertNotNull(task3_new);
377: assertSame(task2_new.getTaskManager(), manager);
378: assertSame(task3_new.getTaskManager(), manager);
379: assertEquals(task2_new.getId(), task2.getId());
380: assertEquals(task2_new.getType(), task2.getType());
381: assertTrue(task2_new.getPlanned() >= task2.getPlanned());
382: assertEquals(task2_new.getFrequency(), task2.getFrequency());
383: assertEquals(task2_new.isBusy(), task2.isBusy());
384: assertEquals(task3_new.getId(), task3.getId());
385: assertEquals(task3_new.getType(), task3.getType());
386: assertTrue(task3_new.getPlanned() <= task3.getPlanned());
387: assertEquals(task3_new.getFrequency(), task3.getFrequency());
388: assertEquals(task3_new.isBusy(), task3_new.isBusy());
389: } catch (FrequencyException e) {
390: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
391: } catch (TaskManagerException e) {
392: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
393: }
394: }
395:
396: public void testTaskActivation() {
397: TaskManager manager = DatabaseTasksFactory
398: .getInstance(mDatasource);
399: try {
400: Task task = new Task();
401: task.setType(TestTasktypes.UPLOAD_GROUPS);
402: task.setPlanned(System.currentTimeMillis());
403: task.setFrequency(null);
404: task.setBusy(false);
405:
406: int taskid = manager.addTask(task);
407:
408: manager.activateTask(taskid);
409: task = manager.getTask(taskid);
410: assertSame(task.getTaskManager(), manager);
411: assertEquals(true, task.isBusy());
412: manager.deactivateTask(taskid);
413: task = manager.getTask(taskid);
414: assertSame(task.getTaskManager(), manager);
415: assertEquals(false, task.isBusy());
416:
417: manager.removeTask(task.getId());
418: } catch (FrequencyException e) {
419: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
420: } catch (TaskManagerException e) {
421: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
422: }
423: }
424: }
|