001: package jfb.tst.tools.activitymgr.core;
002:
003: import jfb.tools.activitymgr.core.DbException;
004: import jfb.tools.activitymgr.core.ModelException;
005: import jfb.tools.activitymgr.core.ModelMgr;
006: import jfb.tools.activitymgr.core.beans.Task;
007: import jfb.tools.activitymgr.core.beans.TaskSearchFilter;
008: import jfb.tools.activitymgr.core.beans.TaskSums;
009: import jfb.tools.activitymgr.core.util.StringHelper;
010: import jfb.tst.tools.activitymgr.AbstractModelTestCase;
011:
012: public class TaskTest extends AbstractModelTestCase {
013:
014: /** Taches de test */
015: private Task rootTask;
016: private Task task1;
017: private Task task11;
018: private Task task111;
019: private Task task112;
020: private Task task2;
021:
022: public void testCreateRootTask() throws DbException, ModelException {
023: // Création des tâches de test
024: Task task = new Task();
025: // Génération d'un code inutilisé
026: task.setCode(String.valueOf(System.currentTimeMillis())
027: .substring(8));
028: task.setName("Root task");
029: task = ModelMgr.createTask(null, task);
030:
031: // Vérification de la génération du numéro
032: assertTrue(task.getNumber() > 0);
033:
034: // Relecture de la tâche en base et comparaison
035: long taskId = task.getId();
036: Task otherTask = ModelMgr.getTask(taskId);
037: assertEquals(task, otherTask); // Seuls les identifiants sont comparés
038: assertEquals(task.getCode(), otherTask.getCode());
039: assertEquals(task.getName(), otherTask.getName());
040: assertEquals(task.getNumber(), otherTask.getNumber());
041:
042: // Suppression
043: ModelMgr.removeTask(task);
044:
045: // Tentative de relecture (l'objet ne doit plus exister)
046: assertNull(ModelMgr.getTask(taskId));
047: }
048:
049: private void createSampleTasks() throws DbException, ModelException {
050: // Création des tâches de test
051: rootTask = ModelMgr.createNewTask(null);
052: rootTask.setCode("RT");
053: rootTask.setName("Root task");
054: rootTask = ModelMgr.updateTask(rootTask);
055:
056: task1 = new Task();
057: task1.setCode("T1");
058: task1.setName("Task 1");
059: task1 = ModelMgr.createTask(rootTask, task1);
060:
061: task11 = new Task();
062: task11.setCode("T11");
063: task11.setName("Task 11");
064: task11 = ModelMgr.createTask(task1, task11);
065:
066: task111 = new Task();
067: task111.setCode("T111");
068: task111.setName("Task 111");
069: task111.setBudget(30);
070: task111.setInitiallyConsumed(5);
071: task111.setTodo(25);
072: task111 = ModelMgr.createTask(task11, task111);
073:
074: task112 = new Task();
075: task112.setCode("T112");
076: task112.setName("Task 112");
077: task112.setBudget(30);
078: task112.setInitiallyConsumed(5);
079: task112.setTodo(25);
080: task112 = ModelMgr.createTask(task11, task112);
081:
082: task2 = new Task();
083: task2.setCode("T2");
084: task2.setName("Task 2");
085: task2.setBudget(60);
086: task2.setInitiallyConsumed(10);
087: task2.setTodo(50);
088: task2 = ModelMgr.createTask(rootTask, task2);
089:
090: // Rechargement des taches pour mise à jour
091: // des nombres de sous-taches
092: rootTask = ModelMgr.getTask(rootTask.getId());
093: task1 = ModelMgr.getTask(task1.getId());
094: task11 = ModelMgr.getTask(task11.getId());
095: task111 = ModelMgr.getTask(task111.getId());
096: task112 = ModelMgr.getTask(task112.getId());
097: task2 = ModelMgr.getTask(task2.getId());
098: }
099:
100: public void removeSampleTasks() throws DbException, ModelException {
101: removeRecursively(rootTask);
102: }
103:
104: private static void removeRecursively(Task task)
105: throws DbException, ModelException {
106: // Récupération des taches filles
107: Task[] subTasks = ModelMgr.getSubtasks(task);
108: for (int i = subTasks.length - 1; i >= 0; i--) {
109: Task subTask = subTasks[i];
110: // Suppression des taches filles
111: removeRecursively(subTask);
112: }
113: // Suppression de la tache
114: ModelMgr.removeTask(task);
115: }
116:
117: public void testTaskPath() throws DbException, ModelException {
118: // Création des taches de test
119: createSampleTasks();
120: try {
121: // Vérification des chemins
122: String expectedPath = StringHelper.toHex(rootTask
123: .getNumber());
124: assertEquals(expectedPath, task1.getPath());
125: assertEquals(expectedPath, task1.getPath());
126: assertEquals(expectedPath + "01", task11.getPath());
127: assertEquals(expectedPath, task2.getPath());
128:
129: // Vérification des numéros
130: assertEquals(1, task1.getNumber());
131: assertEquals(2, task2.getNumber());
132: } finally {
133: // Suppression des taches de test
134: removeSampleTasks();
135: }
136: }
137:
138: public void testGetParent() throws DbException, ModelException {
139: // Création des taches de test
140: createSampleTasks();
141: try {
142: // La tache mère de 11 est 1 ?
143: Task task11Parent = ModelMgr.getParentTask(task11);
144: assertEquals(task1, task11Parent);
145:
146: // La tache mère de 1 est root ?
147: Task task1Parent = ModelMgr.getParentTask(task1);
148: assertEquals(rootTask, task1Parent);
149:
150: // La tache mère de root1 est null ?
151: Task rootTaskParent = ModelMgr.getParentTask(rootTask);
152: assertEquals(null, rootTaskParent);
153: } finally {
154: // Suppression des taches de test
155: removeSampleTasks();
156: }
157: }
158:
159: public void testGetSubtasks() throws DbException, ModelException {
160: // Création des taches de test
161: createSampleTasks();
162: try {
163: // La tache root a-t-elle 2 filles ?
164: Task[] rootTaskSubTasks = ModelMgr.getSubtasks(rootTask);
165: assertEquals(2, rootTaskSubTasks.length);
166:
167: // La tache1 a-t-elle 1 fille ?
168: Task[] task1SubTasks = ModelMgr.getSubtasks(task1);
169: assertEquals(1, task1SubTasks.length);
170:
171: // La tache11 a-t-elle 2 fille ?
172: Task[] task11SubTasks = ModelMgr.getSubtasks(task11);
173: assertEquals(2, task11SubTasks.length);
174:
175: // La tache111 a-t-elle 0 filles ?
176: Task[] task111SubTasks = ModelMgr.getSubtasks(task111);
177: assertEquals(0, task111SubTasks.length);
178:
179: // La tache112 a-t-elle 0 filles ?
180: Task[] task112SubTasks = ModelMgr.getSubtasks(task112);
181: assertEquals(0, task112SubTasks.length);
182:
183: // La tache2 a-t-elle 0 filles ?
184: Task[] task2SubTasks = ModelMgr.getSubtasks(task2);
185: assertEquals(0, task2SubTasks.length);
186: } finally {
187: // Suppression des taches de test
188: removeSampleTasks();
189: }
190: }
191:
192: public void testUpdate() throws DbException, ModelException {
193: // Création des taches de test
194: createSampleTasks();
195: try {
196: // Changement du nom de la tache
197: rootTask.setName("New name");
198: ModelMgr.updateTask(rootTask);
199:
200: // Chargement de la tache et control
201: Task _rootTask = ModelMgr.getTask(rootTask.getId());
202: assertEquals(rootTask.getName(), _rootTask.getName());
203: } finally {
204: // Suppression des taches de test
205: removeSampleTasks();
206: }
207: }
208:
209: public void testMoveDown() throws DbException, ModelException {
210: // Création des taches de test
211: createSampleTasks();
212: try {
213: // Vérification des numéros des taches
214: assertEquals((byte) 1, task1.getNumber());
215: assertEquals((byte) 2, task2.getNumber());
216:
217: // Déplacement + vérification des nouveaux numéros
218: ModelMgr.moveDownTask(task1);
219:
220: // Rechargement des taches
221: task1 = ModelMgr.getTask(task1.getId());
222: task2 = ModelMgr.getTask(task2.getId());
223:
224: // Controls
225: assertEquals((byte) 2, task1.getNumber());
226: assertEquals((byte) 1, task2.getNumber());
227: assertEquals(1, task1.getSubTasksCount());
228: assertEquals(0, task2.getSubTasksCount());
229: } finally {
230: // Suppression des taches de test
231: removeSampleTasks();
232: }
233: }
234:
235: public void testMoveUp() throws DbException, ModelException {
236: // Création des taches de test
237: createSampleTasks();
238: try {
239: // Vérification des numéros des taches
240: assertEquals((byte) 1, task1.getNumber());
241: assertEquals((byte) 2, task2.getNumber());
242:
243: // Déplacement + vérification des nouveaux numéros
244: ModelMgr.moveUpTask(task2);
245:
246: // Rechargement des taches
247: task1 = ModelMgr.getTask(task1.getId());
248: task2 = ModelMgr.getTask(task2.getId());
249:
250: // Controls
251: assertEquals((byte) 2, task1.getNumber());
252: assertEquals((byte) 1, task2.getNumber());
253: assertEquals(1, task1.getSubTasksCount());
254: assertEquals(0, task2.getSubTasksCount());
255: } finally {
256: // Suppression des taches de test
257: removeSampleTasks();
258: }
259: }
260:
261: public void testMove() throws DbException, ModelException {
262: // Création des taches de test
263: createSampleTasks();
264: try {
265: // Vérification des numéros des taches
266: assertEquals(1, task1.getSubTasksCount());
267: assertEquals(task1.getPath() + "01", task11.getPath());
268: assertEquals(task11.getPath() + "01", task111.getPath());
269: assertEquals(task11.getPath() + "01", task112.getPath());
270: assertEquals((byte) 2, task112.getNumber());
271:
272: // Déplacement
273: ModelMgr.moveTask(task111, task1);
274:
275: // Rechargement des taches qui ont été mises à jour
276: task1 = ModelMgr.getTask(task1.getId());
277: task2 = ModelMgr.getTask(task2.getId());
278: task11 = ModelMgr.getTask(task11.getId());
279: task111 = ModelMgr.getTask(task111.getId());
280: task112 = ModelMgr.getTask(task112.getId());
281:
282: // Controls
283: assertEquals(2, task1.getSubTasksCount());
284: assertEquals(task1.getPath() + "01", task11.getPath());
285: assertEquals(task1.getPath() + "01", task111.getPath());
286: assertEquals(task11.getPath() + "01", task112.getPath());
287: assertEquals((byte) 1, task112.getNumber());
288: } finally {
289: // Suppression des taches de test
290: removeSampleTasks();
291: }
292: }
293:
294: public void testTasksSum() throws DbException, ModelException {
295: // Création des taches de test
296: createSampleTasks();
297: try {
298: // Récupération des sommes
299: TaskSums taskSums = ModelMgr.getTaskSums(rootTask);
300: assertEquals(task111.getBudget() + task112.getBudget()
301: + task2.getBudget(), taskSums.getBudgetSum());
302: assertEquals(task111.getInitiallyConsumed()
303: + task112.getInitiallyConsumed()
304: + task2.getInitiallyConsumed(), taskSums
305: .getInitiallyConsumedSum());
306: assertEquals(task111.getTodo() + task112.getTodo()
307: + task2.getTodo(), taskSums.getTodoSum());
308:
309: assertEquals(0, taskSums.getContributionsNb());
310: } finally {
311: // Suppression des taches de test
312: removeSampleTasks();
313: }
314: }
315:
316: public void testSearchTasks() throws DbException, ModelException {
317: // Création des taches de test
318: createSampleTasks();
319: try {
320: // Recherche d'une tache avec le critère "dont le code est égal à..."
321: TaskSearchFilter filter = new TaskSearchFilter();
322: filter.setFieldIndex(TaskSearchFilter.TASK_CODE_FIELD_IDX);
323: filter
324: .setCriteriaIndex(TaskSearchFilter.IS_EQUAL_TO_CRITERIA_IDX);
325: filter.setFieldValue("T1");
326: Task[] tasks = ModelMgr.getTasks(filter);
327: assertNotNull(tasks);
328: assertEquals(1, tasks.length);
329: assertEquals("T1", tasks[0].getCode());
330:
331: // Recherche d'une tache avec le critère "dont le code commence par..."
332: filter = new TaskSearchFilter();
333: filter.setFieldIndex(TaskSearchFilter.TASK_CODE_FIELD_IDX);
334: filter
335: .setCriteriaIndex(TaskSearchFilter.STARTS_WITH_CRITERIA_IDX);
336: filter.setFieldValue("T1");
337: tasks = ModelMgr.getTasks(filter);
338: assertNotNull(tasks);
339: assertEquals(4, tasks.length);
340: assertEquals("T1", tasks[0].getCode());
341: assertEquals("T11", tasks[1].getCode());
342: assertEquals("T111", tasks[2].getCode());
343: assertEquals("T112", tasks[3].getCode());
344:
345: // Recherche d'une tache avec le critère "dont le code finit par..."
346: filter = new TaskSearchFilter();
347: filter.setFieldIndex(TaskSearchFilter.TASK_CODE_FIELD_IDX);
348: filter
349: .setCriteriaIndex(TaskSearchFilter.ENDS_WITH_CRITERIA_IDX);
350: filter.setFieldValue("11");
351: tasks = ModelMgr.getTasks(filter);
352: assertNotNull(tasks);
353: assertEquals(2, tasks.length);
354: assertEquals("T11", tasks[0].getCode());
355: assertEquals("T111", tasks[1].getCode());
356:
357: // Recherche d'une tache avec le critère "dont le code contient..."
358: filter = new TaskSearchFilter();
359: filter.setFieldIndex(TaskSearchFilter.TASK_CODE_FIELD_IDX);
360: filter
361: .setCriteriaIndex(TaskSearchFilter.CONTAINS_WITH_CRITERIA_IDX);
362: filter.setFieldValue("T");
363: tasks = ModelMgr.getTasks(filter);
364: assertNotNull(tasks);
365: assertEquals(6, tasks.length);
366: assertEquals("RT", tasks[0].getCode());
367: assertEquals("T1", tasks[1].getCode());
368: assertEquals("T11", tasks[2].getCode());
369: assertEquals("T111", tasks[3].getCode());
370: assertEquals("T112", tasks[4].getCode());
371: assertEquals("T2", tasks[5].getCode());
372:
373: // Recherche d'une tache avec le critère "dont le code est égal à..."
374: filter = new TaskSearchFilter();
375: filter.setFieldIndex(TaskSearchFilter.TASK_NAME_FIELD_IDX);
376: filter
377: .setCriteriaIndex(TaskSearchFilter.IS_EQUAL_TO_CRITERIA_IDX);
378: filter.setFieldValue("Task 1");
379: tasks = ModelMgr.getTasks(filter);
380: assertNotNull(tasks);
381: assertEquals(1, tasks.length);
382: assertEquals("Task 1", tasks[0].getName());
383:
384: // Recherche d'une tache avec le critère "dont le code commence par..."
385: filter = new TaskSearchFilter();
386: filter.setFieldIndex(TaskSearchFilter.TASK_NAME_FIELD_IDX);
387: filter
388: .setCriteriaIndex(TaskSearchFilter.STARTS_WITH_CRITERIA_IDX);
389: filter.setFieldValue("Task 1");
390: tasks = ModelMgr.getTasks(filter);
391: assertNotNull(tasks);
392: assertEquals(4, tasks.length);
393: assertEquals("Task 1", tasks[0].getName());
394: assertEquals("Task 11", tasks[1].getName());
395: assertEquals("Task 111", tasks[2].getName());
396: assertEquals("Task 112", tasks[3].getName());
397:
398: // Recherche d'une tache avec le critère "dont le code finit par..."
399: filter = new TaskSearchFilter();
400: filter.setFieldIndex(TaskSearchFilter.TASK_NAME_FIELD_IDX);
401: filter
402: .setCriteriaIndex(TaskSearchFilter.ENDS_WITH_CRITERIA_IDX);
403: filter.setFieldValue("11");
404: tasks = ModelMgr.getTasks(filter);
405: assertNotNull(tasks);
406: assertEquals(2, tasks.length);
407: assertEquals("Task 11", tasks[0].getName());
408: assertEquals("Task 111", tasks[1].getName());
409:
410: // Recherche d'une tache avec le critère "dont le code contient..."
411: filter = new TaskSearchFilter();
412: filter.setFieldIndex(TaskSearchFilter.TASK_NAME_FIELD_IDX);
413: filter
414: .setCriteriaIndex(TaskSearchFilter.CONTAINS_WITH_CRITERIA_IDX);
415: filter.setFieldValue("T");
416: tasks = ModelMgr.getTasks(filter);
417: assertNotNull(tasks);
418: assertEquals(5, tasks.length);
419: assertEquals("Task 1", tasks[0].getName());
420: assertEquals("Task 11", tasks[1].getName());
421: assertEquals("Task 111", tasks[2].getName());
422: assertEquals("Task 112", tasks[3].getName());
423: assertEquals("Task 2", tasks[4].getName());
424: } finally {
425: // Suppression des taches de test
426: removeSampleTasks();
427: }
428: }
429:
430: }
|