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: TestDatabaseTaskoptions.java 3634 2007-01-08 21:42:24Z gbevin $
007: */
008: package com.uwyn.rife.scheduler.taskoptionmanagers;
009:
010: import com.uwyn.rife.database.Datasource;
011: import com.uwyn.rife.scheduler.Task;
012: import com.uwyn.rife.scheduler.TaskManager;
013: import com.uwyn.rife.scheduler.Taskoption;
014: import com.uwyn.rife.scheduler.TaskoptionManager;
015: import com.uwyn.rife.scheduler.TestTasktypes;
016: import com.uwyn.rife.scheduler.exceptions.SchedulerException;
017: import com.uwyn.rife.scheduler.exceptions.SchedulerManagerException;
018: import com.uwyn.rife.scheduler.exceptions.TaskoptionManagerException;
019: import com.uwyn.rife.scheduler.schedulermanagers.DatabaseScheduler;
020: import com.uwyn.rife.scheduler.schedulermanagers.DatabaseSchedulerFactory;
021: import com.uwyn.rife.scheduler.taskoptionmanagers.exceptions.InexistentTaskIdException;
022: import com.uwyn.rife.tools.ExceptionUtils;
023: import java.util.Calendar;
024: import java.util.Collection;
025: import junit.framework.TestCase;
026:
027: public class TestDatabaseTaskoptions extends TestCase {
028: private Datasource mDatasource = null;
029:
030: public TestDatabaseTaskoptions(Datasource datasource,
031: String datasourceName, String name) {
032: super (name);
033: mDatasource = datasource;
034: }
035:
036: public void testInstall() {
037: DatabaseScheduler manager = DatabaseSchedulerFactory
038: .getInstance(mDatasource);
039:
040: try {
041: assertTrue(true == manager.install());
042: } catch (SchedulerManagerException e) {
043: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
044: }
045: }
046:
047: public void testRemove() {
048: DatabaseScheduler manager = DatabaseSchedulerFactory
049: .getInstance(mDatasource);
050:
051: try {
052: assertTrue(true == manager.remove());
053: } catch (SchedulerManagerException e) {
054: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
055: }
056: }
057:
058: public void testInstantiateTaskoptionManager() {
059: TaskoptionManager manager = DatabaseTaskoptionsFactory
060: .getInstance(mDatasource);
061: assertNotNull(manager);
062: }
063:
064: public void testAddTaskoptionWithInexistentTaskId() {
065: DatabaseScheduler schedulermanager = DatabaseSchedulerFactory
066: .getInstance(mDatasource);
067: try {
068: schedulermanager.install();
069: } catch (SchedulerManagerException e) {
070: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
071: }
072:
073: Taskoption taskoption = new Taskoption();
074: taskoption.setTaskId(0);
075: taskoption.setName("name");
076: taskoption.setValue("value");
077:
078: TaskoptionManager manager = DatabaseTaskoptionsFactory
079: .getInstance(mDatasource);
080: try {
081: manager.addTaskoption(taskoption);
082: fail();
083: } catch (InexistentTaskIdException e) {
084: assertTrue(true);
085: } catch (TaskoptionManagerException e) {
086: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
087: }
088: }
089:
090: public void testAddTaskoption() {
091: int task_id = 0;
092: Task task = new Task();
093: TaskManager task_manager = DatabaseSchedulerFactory
094: .getInstance(mDatasource).getScheduler()
095: .getTaskManager();
096: TaskoptionManager taskoption_manager = DatabaseSchedulerFactory
097: .getInstance(mDatasource).getScheduler()
098: .getTaskoptionManager();
099: try {
100: Calendar cal = Calendar.getInstance();
101: cal.set(2001, 10, 24, 0, 0, 0);
102:
103: task.setType(TestTasktypes.UPLOAD_GROUPS);
104: task.setPlanned(cal.getTime());
105: task.setFrequency("* * * * *");
106:
107: task_id = task_manager.addTask(task);
108: assertTrue(task_id >= 0);
109:
110: String taskoption_name = "name";
111: String value = "value";
112:
113: Taskoption taskoption = new Taskoption();
114: taskoption.setTaskId(task_id);
115: taskoption.setName(taskoption_name);
116: taskoption.setValue(value);
117:
118: assertTrue(taskoption_manager.addTaskoption(taskoption));
119: } catch (SchedulerException e) {
120: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
121: }
122: }
123:
124: public void testAddDuplicateTaskoption() {
125: int task_id = 0;
126: Task task = new Task();
127: TaskManager task_manager = DatabaseSchedulerFactory
128: .getInstance(mDatasource).getScheduler()
129: .getTaskManager();
130: TaskoptionManager taskoption_manager = DatabaseSchedulerFactory
131: .getInstance(mDatasource).getScheduler()
132: .getTaskoptionManager();
133: try {
134: Calendar cal = Calendar.getInstance();
135: cal.set(2001, 10, 24, 0, 0, 0);
136:
137: task.setType(TestTasktypes.UPLOAD_GROUPS);
138: task.setPlanned(cal.getTime());
139: task.setFrequency("* * * * *");
140:
141: task_id = task_manager.addTask(task);
142: assertTrue(task_id >= 0);
143:
144: String taskoption_name = "name";
145: String value = "value";
146:
147: Taskoption taskoption = new Taskoption();
148: taskoption.setTaskId(task_id);
149: taskoption.setName(taskoption_name);
150: taskoption.setValue(value);
151:
152: assertTrue(taskoption_manager.addTaskoption(taskoption));
153:
154: taskoption_manager.addTaskoption(taskoption);
155: fail();
156: } catch (SchedulerException e) {
157: assertTrue(true);
158: }
159: }
160:
161: public void testGetTaskoption() {
162: int task_id = 0;
163: Task task = new Task();
164: TaskManager task_manager = DatabaseSchedulerFactory
165: .getInstance(mDatasource).getScheduler()
166: .getTaskManager();
167: TaskoptionManager taskoption_manager = DatabaseSchedulerFactory
168: .getInstance(mDatasource).getScheduler()
169: .getTaskoptionManager();
170: try {
171: Calendar cal = Calendar.getInstance();
172: cal.set(2001, 10, 24, 0, 0, 0);
173:
174: task.setType(TestTasktypes.UPLOAD_GROUPS);
175: task.setFrequency("* * * * *");
176:
177: task_id = task_manager.addTask(task);
178: assertTrue(task_id >= 0);
179:
180: String taskoption_name = "name";
181: String value = "value";
182:
183: Taskoption taskoption = new Taskoption();
184: taskoption.setTaskId(task_id);
185: taskoption.setName(taskoption_name);
186: taskoption.setValue(value);
187:
188: assertTrue(taskoption_manager.addTaskoption(taskoption));
189:
190: taskoption = taskoption_manager.getTaskoption(task_id,
191: taskoption_name);
192: assertNotNull(taskoption);
193:
194: assertEquals(taskoption.getTaskId(), task_id);
195: assertEquals(taskoption.getName(), taskoption_name);
196: assertEquals(taskoption.getValue(), value);
197:
198: task = task_manager.getTask(task_id);
199: assertEquals(task.getTaskoptionValue(taskoption_name),
200: value);
201: } catch (SchedulerException e) {
202: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
203: }
204: }
205:
206: public void testUpdateTaskoption() {
207: int task_id = 0;
208: Task task = new Task();
209: TaskManager task_manager = DatabaseSchedulerFactory
210: .getInstance(mDatasource).getScheduler()
211: .getTaskManager();
212: TaskoptionManager taskoption_manager = DatabaseSchedulerFactory
213: .getInstance(mDatasource).getScheduler()
214: .getTaskoptionManager();
215: try {
216: Calendar cal = Calendar.getInstance();
217: cal.set(2001, 10, 24, 0, 0, 0);
218:
219: task.setType(TestTasktypes.UPLOAD_GROUPS);
220: task.setPlanned(cal.getTime());
221: task.setFrequency("* * * * *");
222:
223: task_id = task_manager.addTask(task);
224: assertTrue(task_id >= 0);
225:
226: String taskoption_name = "name";
227: String value = "value";
228:
229: Taskoption taskoption = new Taskoption();
230: taskoption.setTaskId(task_id);
231: taskoption.setName(taskoption_name);
232: taskoption.setValue(value);
233:
234: assertTrue(taskoption_manager.addTaskoption(taskoption));
235:
236: value = "new_value";
237:
238: taskoption = new Taskoption();
239: taskoption.setTaskId(task_id);
240: taskoption.setName(taskoption_name);
241: taskoption.setValue(value);
242:
243: assertTrue(true == taskoption_manager
244: .updateTaskoption(taskoption));
245:
246: taskoption = taskoption_manager.getTaskoption(task_id,
247: taskoption_name);
248: assertNotNull(taskoption);
249:
250: assertEquals(taskoption.getTaskId(), task_id);
251: assertEquals(taskoption.getName(), taskoption_name);
252: assertEquals(taskoption.getValue(), value);
253: } catch (SchedulerException e) {
254: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
255: }
256: }
257:
258: public void testGetTaskoptions() {
259: int task_id = 0;
260: Task task = new Task();
261: TaskManager task_manager = DatabaseSchedulerFactory
262: .getInstance(mDatasource).getScheduler()
263: .getTaskManager();
264: TaskoptionManager taskoption_manager = DatabaseSchedulerFactory
265: .getInstance(mDatasource).getScheduler()
266: .getTaskoptionManager();
267: try {
268: Calendar cal = Calendar.getInstance();
269: cal.set(2001, 10, 24, 0, 0, 0);
270:
271: task.setType(TestTasktypes.UPLOAD_GROUPS);
272: task.setPlanned(cal.getTime());
273: task.setFrequency("* * * * *");
274:
275: task_id = task_manager.addTask(task);
276: assertTrue(task_id >= 0);
277:
278: String taskoption_name = "name";
279: String value = "some_value";
280:
281: Taskoption taskoption = new Taskoption();
282: taskoption.setTaskId(task_id);
283: taskoption.setName(taskoption_name);
284: taskoption.setValue(value);
285:
286: assertTrue(taskoption_manager.addTaskoption(taskoption));
287:
288: Collection<Taskoption> taskoptions = taskoption_manager
289: .getTaskoptions(task_id);
290: assertEquals(1, taskoptions.size());
291:
292: taskoption = taskoptions.iterator().next();
293: assertEquals(taskoption.getTaskId(), task_id);
294: assertEquals(taskoption.getName(), taskoption_name);
295: assertEquals(taskoption.getValue(), "some_value");
296: } catch (SchedulerException e) {
297: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
298: }
299: }
300:
301: public void testRemoveTaskoption() {
302: int task_id = 0;
303: Task task = new Task();
304: TaskManager task_manager = DatabaseSchedulerFactory
305: .getInstance(mDatasource).getScheduler()
306: .getTaskManager();
307: TaskoptionManager taskoption_manager = DatabaseSchedulerFactory
308: .getInstance(mDatasource).getScheduler()
309: .getTaskoptionManager();
310: try {
311: Calendar cal = Calendar.getInstance();
312: cal.set(2001, 10, 24, 0, 0, 0);
313:
314: task.setType(TestTasktypes.UPLOAD_GROUPS);
315: task.setPlanned(cal.getTime());
316: task.setFrequency("* * * * *");
317:
318: task_id = task_manager.addTask(task);
319: assertTrue(task_id >= 0);
320:
321: String taskoption_name = "name";
322: String value = "value";
323:
324: Taskoption taskoption = new Taskoption();
325: taskoption.setTaskId(task_id);
326: taskoption.setName(taskoption_name);
327: taskoption.setValue(value);
328:
329: assertTrue(taskoption_manager.addTaskoption(taskoption));
330:
331: assertTrue(taskoption_manager.removeTaskoption(task_id,
332: taskoption_name));
333:
334: assertTrue(task_manager.removeTask(task_id));
335: task_id = 0;
336: taskoption_name = null;
337: } catch (SchedulerException e) {
338: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
339: }
340: }
341:
342: public void testGetNonExistingTaskoption() {
343: TaskoptionManager manager = DatabaseSchedulerFactory
344: .getInstance(mDatasource).getScheduler()
345: .getTaskoptionManager();
346: int task_nonexisting_id = 340;
347: try {
348: assertNull(manager.getTaskoption(task_nonexisting_id,
349: "unknownname"));
350: } catch (TaskoptionManagerException e) {
351: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
352: }
353: }
354:
355: public void testRemoveNonExistingTaskoption() {
356: TaskoptionManager manager = DatabaseSchedulerFactory
357: .getInstance(mDatasource).getScheduler()
358: .getTaskoptionManager();
359: int task_nonexisting_id = 120;
360: try {
361: assertTrue(false == manager.removeTaskoption(
362: task_nonexisting_id, "unknownname"));
363: } catch (TaskoptionManagerException e) {
364: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
365: }
366:
367: DatabaseScheduler schedulermanager = DatabaseSchedulerFactory
368: .getInstance(mDatasource);
369: try {
370: schedulermanager.remove();
371: } catch (SchedulerManagerException e) {
372: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
373: }
374: }
375: }
|