1
2
3
4 package org.itracker.services.implementations;
5
6 import org.apache.log4j.Logger;
7 import org.itracker.AbstractDependencyInjectionTest;
8 import org.itracker.IssueException;
9 import org.itracker.IssueSearchException;
10 import org.itracker.ProjectException;
11 import org.itracker.core.resources.ITrackerResources;
12 import org.itracker.model.*;
13 import org.itracker.model.CustomField.Type;
14 import org.itracker.model.util.IssueUtilities;
15 import org.itracker.persistence.dao.*;
16 import org.itracker.services.IssueService;
17 import org.itracker.services.UserService;
18 import org.itracker.services.util.AuthenticationConstants;
19 import org.itracker.web.util.ServletContextUtils;
20 import org.junit.Test;
21
22 import java.text.SimpleDateFormat;
23 import java.util.*;
24
25
26
27
28 public class IssueServiceIT extends AbstractDependencyInjectionTest {
29
30 private static final Logger logger = Logger
31 .getLogger(IssueServiceIT.class);
32 private IssueService issueService;
33
34 private UserDAO userDAO;
35 private IssueDAO issueDAO;
36 private IssueRelationDAO issueRelationDAO;
37 private IssueHistoryDAO issueHistoryDAO;
38 private IssueAttachmentDAO issueAttachmentDAO;
39
40
41
42
43
44 @Test
45 public void testGetIssue() {
46
47 Issue issue = this.issueService.getIssue(1);
48
49 assertNotNull("issue#1", issue);
50
51 this.issueService.getIssue(2);
52 assertNotNull("issue#2", issue);
53
54 this.issueService.getIssue(3);
55 assertNotNull("issue#3", issue);
56
57 this.issueService.getIssue(4);
58 assertNotNull("issue#4", issue);
59
60 }
61
62
63
64
65
66 @Test
67 public void testGetNumberIssues() {
68
69 Long nrOfIssues = issueService.getNumberIssues();
70 assertEquals("allissues", (Long) 4l, nrOfIssues);
71
72 }
73
74
75
76
77
78 @Test
79 public void testGetIssuesWithStatus() {
80
81 Collection<Issue> issues = issueService.getIssuesWithStatus(100);
82 assertEquals("status 1 issues", 1, issues.size());
83 issues = issueService.getIssuesWithStatus(200);
84 assertEquals("status 2 issues", 1, issues.size());
85 issues = issueService.getIssuesWithStatus(300);
86 assertEquals("status 3 issues", 2, issues.size());
87
88 }
89
90
91
92
93
94
95 @Test
96 public void testGetIssuesWithStatusLessThan() {
97 Collection<Issue> issues = issueService.getIssuesWithStatusLessThan(200);
98 assertEquals("status less 2 issues", 1, issues.size());
99
100 issues = issueService.getIssuesWithStatusLessThan(300);
101 assertEquals("status less 3 issues", 2, issues.size());
102 }
103
104
105
106
107
108 @Test
109 public void testGetIssuesWithSeverity() {
110 Collection<Issue> issues = issueService.getIssuesWithSeverity(1);
111
112 assertEquals("issues severity#1", 4, issues.size());
113 assertTrue("issue#1 countained", issues.contains(issueService
114 .getIssue(1)));
115 }
116
117
118
119
120
121
122 @Test
123 public void testGetIssuesByProjectIdInteger() {
124 Collection<Issue> issues = issueService.getIssuesByProjectId(2);
125
126 assertEquals("issues by project#2", 4, issues.size());
127 }
128
129
130
131
132
133
134 @Test
135 public void testGetIssuesByProjectIdIntegerInt() {
136 Collection<Issue> issues = issueService.getIssuesByProjectId(2, 200);
137 assertEquals("issues count", 1, issues.size());
138 issues = issueService.getIssuesByProjectId(2, 300);
139 assertEquals("issues count", 2, issues.size());
140 }
141
142
143
144
145
146
147 @Test
148 public void testGetIssuesCreatedByUserInteger() {
149 Collection<Issue> issues = issueService.getIssuesCreatedByUser(3);
150 assertEquals("issues count createdBy#3", 0, issues.size());
151
152 issues = issueService.getIssuesCreatedByUser(2);
153 assertEquals("issues count createdBy#2", 4, issues.size());
154 }
155
156
157
158
159
160
161 @Test
162 public void testGetIssuesCreatedByUserIntegerBoolean() {
163
164 Collection<Issue> issues = issueService
165 .getIssuesCreatedByUser(2, false);
166 assertEquals("issues count createdBy#3", 4, issues.size());
167
168 issues = issueService.getIssuesCreatedByUser(2, true);
169 assertEquals("issues count createdBy#2", 4, issues.size());
170 }
171
172
173
174
175
176
177 @Test
178 public void testGetIssuesOwnedByUserInteger() {
179 Collection<Issue> issues = issueService.getIssuesOwnedByUser(2);
180 assertEquals("issues count owner#2", 4, issues.size());
181 }
182
183
184
185
186
187
188 @Test
189 public void testGetIssuesOwnedByUserIntegerBoolean() {
190
191 Collection<Issue> issues = issueService.getIssuesOwnedByUser(2, false);
192 assertEquals("issues count owner#2", 4, issues.size());
193
194 issues = issueService.getIssuesOwnedByUser(2, true);
195 assertEquals("issues count owner#2", 4, issues.size());
196 }
197
198
199
200
201
202
203 @Test
204 public void testGetIssuesWatchedByUser() {
205 Collection<Issue> issues = issueService.getIssuesWatchedByUser(2);
206 assertNotNull(issues);
207 assertEquals("issues watched by#2", 1, issues.size());
208
209 issues = issueService.getIssuesWatchedByUser(2, false);
210 assertNotNull(issues);
211 assertEquals("issues watched by#2 regardless of project status", 1, issues.size());
212 }
213
214
215
216
217
218 @Test
219 public void testGetUnassignedIssues() {
220 List<Issue> issues = issueService.getUnassignedIssues();
221 assertNotNull(issues);
222
223
224 assertEquals("2 unassigned issues", 2, issues.size());
225
226 issues = issueService.getUnassignedIssues(false);
227 assertNotNull(issues);
228
229
230 assertEquals("2 unassigned issues", 2, issues.size());
231
232
233
234 }
235
236
237
238
239
240
241 @Test
242 public void testCreateIssue() {
243 Issue issue = new Issue();
244 issue.setStatus(1);
245 issue.setDescription("hi");
246 issue.setSeverity(1);
247 User user = ((UserService) applicationContext.getBean("userService"))
248 .getUser(2);
249 assertNotNull("user#2", user);
250 IssueHistory history = new IssueHistory(issue, user);
251 history.setDescription("hello");
252 history.setStatus(1);
253
254 try {
255 Issue newIssue = issueService.createIssue(issue, 2, user.getId(),
256 user.getId());
257 assertNotNull("new issue", newIssue);
258 assertNotNull("model issue id", issue.getId());
259 assertNotNull("new issue id", issue.getId());
260 assertTrue("new issue id == model issue id",
261 newIssue.getId() == issue.getId());
262
263 } catch (ProjectException e) {
264 e.printStackTrace();
265 fail(e.getMessage());
266 }
267 }
268
269
270
271
272
273
274 @Test
275 public void testUpdateIssue() {
276 Issue updateIssue = issueService.getIssue(2);
277 assertNotNull("issue", updateIssue);
278
279 User user = ((UserService) applicationContext.getBean("userService"))
280 .getUser(2);
281 assertNotNull("user#2", user);
282
283 IssueHistory history = new IssueHistory(updateIssue, user, "hi", 1);
284 Integer histCount = updateIssue.getHistory().size();
285
286 updateIssue.getHistory().add(history);
287
288 try {
289 updateIssue = issueService.updateIssue(updateIssue, 2);
290 assertEquals("new history size", histCount + 1, updateIssue
291 .getHistory().size());
292
293 } catch (ProjectException e) {
294 logger.error("testUpdateIssue", e);
295 fail(e.getMessage());
296 }
297
298 }
299
300 @Test
301 public void testUpdateIssueSeverity() throws Exception {
302 Issue updateIssue = issueService.getIssue(2);
303 assertNotNull("issue", updateIssue);
304
305 User user = ((UserService) applicationContext.getBean("userService"))
306 .getUser(2);
307 assertNotNull("user#2", user);
308
309 IssueHistory history = new IssueHistory(updateIssue, user, "hi", 1);
310
311 Integer actCount = updateIssue.getActivities().size();
312
313 updateIssue.getHistory().add(history);
314 int severity = updateIssue.getSeverity() + 1;
315
316 updateIssue.setSeverity(severity);
317
318 try {
319
320 updateIssue = issueService.updateIssue(updateIssue, 2);
321
322 assertEquals("new activity size", actCount + 1, updateIssue
323 .getActivities().size());
324
325 assertEquals("new issue severity", severity, updateIssue
326 .getSeverity().intValue());
327
328 assertEquals("new added activity type",
329 IssueActivityType.SEVERITY_CHANGE, issueService.getIssue(
330 updateIssue.getId()).getActivities().get(
331 updateIssue.getActivities().size() - 1)
332 .getActivityType());
333
334
335
336
337
338
339 } catch (ProjectException e) {
340 e.printStackTrace();
341 fail(e.getMessage());
342 }
343 }
344
345 @Test
346 public void testUpdateIssueDescription() throws Exception {
347 Issue updateIssue = issueService.getIssue(2);
348 assertNotNull("issue", updateIssue);
349
350 User user = ((UserService) applicationContext.getBean("userService"))
351 .getUser(2);
352 assertNotNull("user#2", user);
353
354 IssueHistory history = new IssueHistory(updateIssue, user, "hi", 1);
355
356 Integer actCount = updateIssue.getActivities().size();
357
358 updateIssue.getHistory().add(history);
359 String description = "new issue description";
360
361 updateIssue.setDescription(description);
362
363 try {
364
365 updateIssue = issueService.updateIssue(updateIssue, 2);
366
367 assertEquals("updateIssue.activities.size", actCount + 1,
368 updateIssue.getActivities().size());
369
370 assertEquals("updateIssue.description", description, updateIssue
371 .getDescription());
372
373 assertEquals("updateIssue.activity.last.type",
374 IssueActivityType.DESCRIPTION_CHANGE, updateIssue
375 .getActivities().get(
376 updateIssue.getActivities().size() - 1)
377 .getActivityType());
378
379 Issue reloadedIssue = issueService.getIssue(updateIssue.getId());
380
381 assertEquals("reloadedIssue.activities.size", actCount + 1,
382 updateIssue.getActivities().size());
383
384 assertEquals("reloadedIssue.description", description, updateIssue
385 .getDescription());
386
387 assertEquals("reloadedIssue.activity.last.type",
388 IssueActivityType.DESCRIPTION_CHANGE, reloadedIssue
389 .getActivities().get(
390 reloadedIssue.getActivities().size() - 1)
391 .getActivityType());
392 } catch (ProjectException e) {
393 logger.error("testUpdateIssueDescription: failed to test, failing",
394 e);
395 fail(e.getMessage());
396 }
397 }
398
399 @Test
400 public void testUpdateIssueResolution() throws Exception {
401 Issue updateIssue = issueService.getIssue(2);
402 assertNotNull("issue", updateIssue);
403
404 User user = ((UserService) applicationContext.getBean("userService"))
405 .getUser(2);
406 assertNotNull("user#2", user);
407
408 IssueHistory history = new IssueHistory(updateIssue, user, "hi", 1);
409
410 Integer actCount = updateIssue.getActivities().size();
411
412 updateIssue.getHistory().add(history);
413 String resolution = "new issue resolution";
414
415 updateIssue.setResolution(resolution);
416
417 try {
418
419 updateIssue = issueService.updateIssue(updateIssue, 2);
420
421 assertEquals("new activity size", actCount + 1, updateIssue
422 .getActivities().size());
423
424 assertEquals("new issue resolution", resolution, updateIssue
425 .getResolution());
426
427 assertEquals("new added activity type",
428 IssueActivityType.RESOLUTION_CHANGE, issueService.getIssue(
429 updateIssue.getId()).getActivities().get(
430 updateIssue.getActivities().size() - 1)
431 .getActivityType());
432
433 } catch (ProjectException e) {
434 e.printStackTrace();
435 fail(e.getMessage());
436 }
437 }
438
439
440
441
442
443
444 @Test
445 public void testMoveIssue() {
446
447 Issue issue = issueService.getIssue(1);
448 assertNotNull("issue", issue);
449 User user = ((UserService) applicationContext.getBean("userService"))
450 .getUser(2);
451 Integer actCount = issue.getActivities().size();
452 assertNotNull("user#2", user);
453 issue = issueService.moveIssue(issue, 3, user.getId());
454
455 Issue reloaded = issueService.getIssue(1);
456
457 assertEquals("issue.project.id", Integer.valueOf(3), issue.getProject()
458 .getId());
459 assertEquals("reloaded.project.id", Integer.valueOf(3), reloaded
460 .getProject().getId());
461
462 assertEquals("reloaded.activities.size", actCount + 1, reloaded
463 .getActivities().size());
464
465
466
467 }
468
469
470
471
472
473
474 @Test
475 public void testAssignIssueIntegerInteger() {
476
477 Issue issue = issueService.getIssue(2);
478 assertNotNull("issue", issue);
479 User user = ((UserService) applicationContext.getBean("userService"))
480 .getUser(4);
481 assertNotNull("user#2", user);
482
483 assertTrue("assigned", issueService.assignIssue(issue.getId(), user
484 .getId()));
485
486 assertEquals("owner", user, issue.getOwner());
487
488 }
489
490
491
492
493
494
495 @Test
496 public void testAssignIssueIntegerIntegerInteger() {
497 Issue issue = issueService.getIssue(2);
498 assertNotNull("issue", issue);
499 User user = ((UserService) applicationContext.getBean("userService"))
500 .getUser(4);
501 User assignerUser = ((UserService) applicationContext
502 .getBean("userService")).getUser(2);
503 assertNotNull("user#2", user);
504
505 assertTrue("assigned", issueService.assignIssue(issue.getId(), user
506 .getId(), assignerUser.getId()));
507
508 assertEquals("owner", user, issue.getOwner());
509
510 try {
511 assertTrue("unassigned", issueService.assignIssue(issue.getId(), null, assignerUser.getId()));
512 fail("null user allowed");
513 } catch (Exception e) { }
514 }
515
516
517
518
519
520
521
522 @Test
523 public void testSetIssueFields() {
524 Issue issue = issueService.getIssue(2);
525 assertNotNull("issue", issue);
526 assertEquals("issue.fields.size", 2, issue.getProject().getCustomFields().size());
527
528 assertEquals("issue.fields[0].customField", issue.getProject().getCustomFields().get(0), issue.getFields().get(0).getCustomField());
529
530 IssueField field = issue.getFields().get(0);
531 assertEquals("issue.fields[0].fieldType", Type.STRING, field.getCustomField().getFieldType());
532
533 try {
534 field.setValue("1", ITrackerResources.getBundle(Locale.US));
535 } catch (IssueException e) {
536 logger.error("testSetIssueFields: failed to set value", e);
537 fail(e.getMessage());
538 }
539
540 issueService.setIssueFields(issue.getId(), issue.getFields());
541
542 CustomField dateField = issue.getProject().getCustomFields().get(1);
543 IssueField dateFieldValue = new IssueField(issue, dateField);
544
545
546 dateFieldValue.setDateValue(new Date(122255164431l));
547
548
549 ArrayList<IssueField> issueFields = new ArrayList<IssueField>(issue.getFields().size() + 1);
550 issueFields.add(dateFieldValue);
551
552 issueService.setIssueFields(issue.getId(), issueFields);
553
554 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
555 issue = issueService.getIssue(2);
556
557 assertEquals("issue.fields[0]", field, issue.getFields().get(0));
558 assertEquals("issue.fields[1]", df.format(dateFieldValue.getDateValue()), df.format(issue.getFields().get(1).getDateValue().getTime()));
559
560 boolean added = issueService.setIssueFields(issue.getId(), new ArrayList<IssueField>());
561 assertTrue(added);
562
563 }
564
565 @Test
566 public void testUpdateIssueCustomFields() {
567
568 Issue issue = issueService.getIssue(2);
569 assertNotNull("issue", issue);
570 assertEquals("issue.fields.size", 2, issue.getProject().getCustomFields().size());
571
572 assertEquals("issue.fields[0].customField", issue.getProject().getCustomFields().get(0), issue.getFields().get(0).getCustomField());
573
574 IssueField field = issue.getFields().get(0);
575 assertEquals("issue.fields[0].fieldType", Type.STRING, field.getCustomField().getFieldType());
576
577 try {
578 field.setValue("1", ITrackerResources.getBundle(Locale.US));
579
580 } catch (IssueException e) {
581 logger.error("testSetIssueFields: failed to set value", e);
582 fail(e.getMessage());
583 }
584
585 try {
586 issueService.updateIssue(issue, issue.getOwner().getId());
587 } catch (ProjectException e) {
588 logger.error("testSetIssueFields: failed to update issue", e);
589 fail(e.getMessage());
590 }
591
592
593 CustomField dateField = issue.getProject().getCustomFields().get(1);
594 IssueField dateFieldValue = new IssueField(issue, dateField);
595
596
597 dateFieldValue.setDateValue(new Date(122255164431l));
598
599 issue.getFields().add(dateFieldValue);
600
601 try {
602 issueService.updateIssue(issue, issue.getOwner().getId());
603 } catch (ProjectException e) {
604 logger.error("testSetIssueFields: failed to update issue", e);
605 fail(e.getMessage());
606 }
607
608 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
609 issue = issueService.getIssue(2);
610
611 assertEquals("issue.fields[0]", field, issue.getFields().get(0));
612 assertEquals("issue.fields[1]", df.format(dateFieldValue.getDateValue()), df.format(issue.getFields().get(1).getDateValue().getTime()));
613
614
615 }
616
617
618
619
620
621
622 @Test
623 public void testSetIssueComponents() {
624 HashSet<Integer> componentIds = new HashSet<Integer>();
625 componentIds.add(1);
626 boolean updated = issueService.setIssueComponents(3, componentIds, 2);
627 assertTrue(updated);
628 issueService.getIssueComponentIds(3).contains(1);
629
630 }
631
632
633
634
635
636
637 @Test
638 public void testSetIssueVersions() {
639 HashSet<Integer> versionIds = new HashSet<Integer>();
640 versionIds.add(1);
641 boolean updated = issueService.setIssueVersions(3, versionIds, 2);
642 assertTrue(updated);
643 issueService.getIssueVersionIds(3).contains(1);
644 }
645
646
647
648
649
650
651 @Test
652 public void testAddIssueHistory() {
653
654 Issue issue = issueDAO.findByPrimaryKey(1);
655 User user = userDAO.findByPrimaryKey(2);
656
657 IssueHistory history = new IssueHistory(issue, user, "", IssueUtilities.STATUS_NEW);
658
659 history.setIssue(issue);
660 issueService.addIssueHistory(history);
661
662 assertNotNull(issueHistoryDAO.findByPrimaryKey(history.getId()));
663 }
664
665
666
667
668
669
670 @Test
671 public void testAddIssueRelation() {
672
673 boolean added = issueService.addIssueRelation(2, 3, IssueRelation.Type.DUPLICATE_C, 2);
674 assertTrue(added);
675
676
677 List<IssueRelation> issueRelations = issueRelationDAO.findByIssue(2);
678 assertNotNull(issueRelations);
679 assertEquals("issueRelations.size()", 1, issueRelations.size());
680 IssueRelation issueRelation = issueRelations.get(0);
681 assertNotNull(issueRelation);
682 assertNotNull("issueRelation.id", issueRelation.getId());
683 assertEquals("issueRelation.relatedIssue.id", new Integer(3), issueRelation.getRelatedIssue().getId());
684 assertEquals("issueRelation.relationType", IssueRelation.Type.DUPLICATE_C, issueRelation.getRelationType());
685
686 }
687
688
689
690
691
692
693 @Test
694 public void testAddIssueAttachment() {
695 Issue issue = issueDAO.findByPrimaryKey(1);
696 assertNotNull(issue.getAttachments());
697 int attachments = issue.getAttachments().size();
698 IssueAttachment attachment = new IssueAttachment(issue, "my_file", "text/xml", "", 0);
699 attachment.setUser(userDAO.findByPrimaryKey(2));
700 boolean added = issueService.addIssueAttachment(attachment, new byte[]{});
701 assertTrue("attachment added", added);
702
703 issue = issueDAO.findByPrimaryKey(1);
704 assertNotNull(issue.getAttachments());
705 assertEquals("atachment added", attachments + 1, issue.getAttachments().size());
706
707 }
708
709 @Test
710 public void testSetIssueAttachmentData() {
711 boolean modified = issueService.setIssueAttachmentData(1, new byte[]{9, 8, 7});
712 assertTrue("attachment modified", modified);
713
714 IssueAttachment attachment = issueAttachmentDAO.findByPrimaryKey(1);
715 assertNotNull(attachment.getFileData());
716 assertTrue("updated data", Arrays.equals(new byte[]{9, 8, 7}, attachment.getFileData()));
717
718
719 modified = issueService.setIssueAttachmentData("Derived Filename 1", new byte[]{7, 8, 9});
720 assertTrue("attachment modified", modified);
721
722 attachment = issueAttachmentDAO.findByPrimaryKey(1);
723 assertNotNull(attachment.getFileData());
724 assertTrue("updated data", Arrays.equals(new byte[]{7, 8, 9}, attachment.getFileData()));
725
726
727 }
728
729
730
731
732
733
734 @Test
735 public void testRemoveIssueAttachment() {
736 boolean removed = issueService.removeIssueAttachment(1);
737 assertTrue("attachment removed", removed);
738 assertNull("no db attachment", issueAttachmentDAO.findByPrimaryKey(1));
739 }
740
741
742
743
744
745
746 @Test
747
748 public void testRemoveIssueHistoryEntry() {
749 IssueHistory issueHistory = issueHistoryDAO.findByPrimaryKey(1);
750 assertNotNull(issueHistory);
751 issueService.removeIssueHistoryEntry(1, 2);
752 issueHistory = issueHistoryDAO.findByPrimaryKey(1);
753 assertNull(issueHistory);
754 }
755
756
757
758
759
760
761 @Test
762 public void testRemoveIssueRelation() {
763 IssueRelation issueRelation = issueRelationDAO.findByPrimaryKey(1);
764 assertNotNull("issueRelation", issueRelation);
765
766 issueService.removeIssueRelation(1, 2);
767
768 issueRelation = issueRelationDAO.findByPrimaryKey(1);
769 assertNull("issueRelation", issueRelation);
770 }
771
772
773
774
775
776
777 @Test
778 public void testGetIssueProject() {
779 Issue issue = issueService.getIssue(2);
780
781 assertEquals("issue project", issue.getProject(), issueService
782 .getIssueProject(issue.getId()));
783 }
784
785
786
787
788
789
790 @Test
791 public void testGetIssueVersions() {
792
793 List<Version> versions = issueService.getIssueVersions(1);
794 assertNotNull(versions);
795 assertEquals(1, versions.size());
796 assertEquals("version id", new Integer(1), versions.get(0).getId());
797
798 }
799
800
801
802
803
804
805 @Test
806 public void testGetIssueVersionIds() {
807 Set<Integer> versions = issueService.getIssueVersionIds(1);
808 assertNotNull(versions);
809 assertEquals(1, versions.size());
810 assertTrue("version id", versions.contains(new Integer(1)));
811 }
812
813
814
815
816
817
818 @Test
819 public void testGetIssueCreator() {
820
821 Collection<Issue> issues = issueService.getIssuesCreatedByUser(2);
822
823 Iterator<Issue> issuesIt = issues.iterator();
824 while (issuesIt.hasNext()) {
825 Issue issue = (Issue) issuesIt.next();
826 assertEquals("creator", (Integer) 2, issue.getCreator().getId());
827 }
828
829 User creator = issueService.getIssueCreator(1);
830 assertNotNull(creator);
831 assertEquals(new Integer(2), creator.getId());
832
833 }
834
835
836
837
838
839
840 @Test
841 public void testGetIssueOwner() {
842
843 Collection<Issue> issues = issueService.getIssuesOwnedByUser(2);
844
845 Iterator<Issue> issuesIt = issues.iterator();
846 while (issuesIt.hasNext()) {
847 Issue issue = (Issue) issuesIt.next();
848 assertEquals("creator", (Integer) 2, issue.getOwner().getId());
849 }
850
851 User owner = issueService.getIssueOwner(1);
852 assertNotNull(owner);
853 assertEquals(new Integer(2), owner.getId());
854
855 }
856
857
858
859
860
861
862 @Test
863 public void testGetIssueActivityInteger() {
864 List<IssueActivity> issueActivities = issueService.getIssueActivity(1);
865 assertNotNull(issueActivities);
866 assertEquals("issue activities for issue#1", 1, issueActivities.size());
867
868 issueActivities = issueService.getIssueActivity(4);
869 assertNotNull(issueActivities);
870 assertEquals("issue activities for issue#4", 1, issueActivities.size());
871
872 }
873
874
875
876
877
878
879 @Test
880 public void testGetIssueActivityIntegerBoolean() {
881 List<IssueActivity> issueActivities = issueService.getIssueActivity(1, true);
882 assertNotNull(issueActivities);
883 assertEquals("issue activities for issue#1 (with notification)", 1, issueActivities.size());
884
885 issueActivities = issueService.getIssueActivity(1, false);
886 assertNotNull(issueActivities);
887 assertEquals("issue activities for issue#1 (without notification)", 0, issueActivities.size());
888 }
889
890
891
892
893
894 @Test
895 public void testGetAllIssueAttachmentCount() {
896 assertEquals("total attachments", new Long(4), issueService.getAllIssueAttachmentCount());
897 }
898
899 @Test
900 public void testGetAllIssueAttachmentSize() {
901 Long size = 0l;
902 Iterator<IssueAttachment> attIt = issueAttachmentDAO.findAll().iterator();
903 while (attIt.hasNext()) {
904 IssueAttachment issueAttachment = (IssueAttachment) attIt.next();
905 assertNotNull(issueAttachment);
906 size += issueAttachment.getSize();
907 }
908 size = size / 1024;
909 assertEquals("total attachmentsSize", size, issueService.getAllIssueAttachmentSize());
910 }
911
912
913
914
915
916
917
918 @Test
919 public void testGetLastIssueHistory() {
920 IssueHistory issueHistory = issueService.getLastIssueHistory(2);
921 assertNotNull("issueHistory", issueHistory);
922 assertEquals("issueHistory id", new Integer(1), issueHistory.getId());
923 }
924
925
926
927
928
929
930 @Test
931 public void testCanViewIssue() {
932
933 Issue issue1 = issueDAO.findByPrimaryKey(1);
934
935 assertTrue("view issue#1 permission for user#2",
936 issueService.canViewIssue(1, userDAO.findByPrimaryKey(2)));
937 assertTrue("view issue#1 permission for user#2",
938 issueService.canViewIssue(issue1, userDAO.findByPrimaryKey(2)));
939
940 assertFalse("view issue#1 permission for user#3",
941 issueService.canViewIssue(1, userDAO.findByPrimaryKey(3)));
942 assertFalse("view issue#1 permission for user#3",
943 issueService.canViewIssue(issue1, userDAO.findByPrimaryKey(3)));
944
945 assertTrue("view issue#1 permission for user#4",
946 issueService.canViewIssue(1, userDAO.findByPrimaryKey(4)));
947 assertTrue("view issue#1 permission for user#4",
948 issueService.canViewIssue(issue1, userDAO.findByPrimaryKey(4)));
949
950 }
951
952
953
954
955
956
957 @Test
958 public void testSearchIssues() {
959 Issue expected = issueService.getIssue(2);
960 assertNotNull("expected", expected);
961 assertEquals("expected.history[0].description", "hello..", expected
962 .getHistory().get(0).getDescription());
963
964 IssueSearchQuery query = new IssueSearchQuery();
965
966 query.setText("hello");
967
968 ArrayList<Integer> projectIds = new ArrayList<Integer>();
969 projectIds.add(2);
970 query.setProjects(projectIds);
971
972 User user = expected.getOwner();
973
974 Map<Integer, Set<PermissionType>> permissionsMap = ServletContextUtils
975 .getItrackerServices().getUserService()
976 .getUsersMapOfProjectIdsAndSetOfPermissionTypes(user,
977 AuthenticationConstants.REQ_SOURCE_WEB);
978
979 try {
980 List<Issue> result = issueService.searchIssues(query, user,
981 permissionsMap);
982 assertTrue("result.contains(expected)", result.contains(expected));
983 } catch (IssueSearchException e) {
984 logger.error("testSearchIssues: failed to search issues", e);
985 fail(e.getMessage());
986 }
987 }
988
989
990 @Test
991 public void testGetIssueComponents() {
992 List<Component> components = issueService.getIssueComponents(1);
993 assertNotNull(components);
994 assertEquals(1, components.size());
995
996 components = issueService.getIssueComponents(4);
997 assertNotNull(components);
998 assertEquals(0, components.size());
999
1000 }
1001
1002 @Test
1003 public void testGetIssueComponentIds() {
1004 Set<Integer> componentIds = issueService.getIssueComponentIds(1);
1005 assertNotNull(componentIds);
1006 assertEquals("component ids for issue#1", 1, componentIds.size());
1007
1008 componentIds = issueService.getIssueComponentIds(4);
1009 assertNotNull(componentIds);
1010 assertEquals("component ids for issue#4", 0, componentIds.size());
1011
1012 }
1013
1014 @Test
1015 public void testGetIssueAttachments() {
1016 List<IssueAttachment> attachments = issueService.getIssueAttachments(1);
1017 assertNotNull(attachments);
1018 assertEquals(4, attachments.size());
1019
1020 attachments = issueService.getIssueAttachments(2);
1021 assertNotNull(attachments);
1022 assertEquals(0, attachments.size());
1023
1024 }
1025
1026 @Test
1027 public void testGetIssueAttachment() {
1028 IssueAttachment attachment = issueService.getIssueAttachment(1);
1029 assertNotNull(attachment);
1030 assertEquals("attachment id", new Integer(1), attachment.getId());
1031 assertEquals("attachment file name", "Derived Filename 1", attachment.getFileName());
1032
1033 }
1034
1035 @Test
1036 public void testGetIssueAttachmentData() {
1037 byte[] data = issueService.getIssueAttachmentData(1);
1038 assertNotNull(data);
1039 assertEquals("attachment1.xml size", 44, data.length);
1040
1041 }
1042
1043 @Test
1044 public void testGetIssueHistory() {
1045 List<IssueHistory> historyItems = issueService.getIssueHistory(1);
1046 assertNotNull(historyItems);
1047 assertEquals(0, historyItems.size());
1048
1049 historyItems = issueService.getIssueHistory(2);
1050 assertNotNull(historyItems);
1051 assertEquals(1, historyItems.size());
1052
1053 }
1054
1055 @Test
1056 public void testGetIssueAttachmentCount() {
1057 assertEquals("attachment count for issue#1", 4, issueService.getIssueAttachmentCount(1));
1058 assertEquals("attachment count for issue#4", 0, issueService.getIssueAttachmentCount(4));
1059
1060 }
1061
1062 @Test
1063 public void testGetOpenIssueCountByProjectId() {
1064 assertEquals("open issues for project#2", 4, issueService.getOpenIssueCountByProjectId(2));
1065 assertEquals("open issues for project#3", 0, issueService.getOpenIssueCountByProjectId(3));
1066
1067 }
1068
1069 @Test
1070 public void testGetResolvedIssueCountByProjectId() {
1071 assertEquals("resolved issues for project#2", 0, issueService.getResolvedIssueCountByProjectId(2));
1072 assertEquals("resolved issues for project#3", 0, issueService.getResolvedIssueCountByProjectId(3));
1073
1074 }
1075
1076 @Test
1077 public void testGetTotalIssueCountByProjectId() {
1078 assertEquals("total issues for project#2", 4, issueService.getTotalIssueCountByProjectId(2));
1079 assertEquals("total issues for project#3", 0, issueService.getTotalIssueCountByProjectId(3));
1080
1081 }
1082
1083 @Test
1084 public void testGetLatestIssueDateByProjectId() {
1085 Date date = issueService.getLatestIssueDateByProjectId(2);
1086 assertEquals("latest issue date for project#2", "2008-01-01", new SimpleDateFormat("yyyy-MM-dd").format(date));
1087 assertNull("latest issue date for project#3", issueService.getLatestIssueDateByProjectId(3));
1088
1089 }
1090
1091
1092 @Test
1093 public void testSystemUpdateIssue() {
1094 Issue issue = issueDAO.findByPrimaryKey(1);
1095 try {
1096 issueService.systemUpdateIssue(issue, 2);
1097 issue = issueDAO.findByPrimaryKey(1);
1098 assertNotNull(issue);
1099 assertNotNull(issue.getActivities());
1100 boolean hasSystemTypeActivity = false;
1101 for (IssueActivity activity : issue.getActivities()) {
1102 if (IssueActivityType.SYSTEM_UPDATE.equals(activity.getActivityType())) {
1103 hasSystemTypeActivity = true;
1104 break;
1105 }
1106 }
1107 assertTrue("has SYSTEM_UPDATE activity", hasSystemTypeActivity);
1108
1109 } catch (ProjectException e) {
1110 fail(e.getMessage());
1111 }
1112
1113 }
1114
1115 @SuppressWarnings("deprecation")
1116 @Test
1117 public void testSetNotificationService() {
1118 List<Issue> issues = issueService.getAllIssues();
1119 assertNotNull(issues);
1120 assertEquals("4 issues", 4, issues.size());
1121 }
1122
1123 @Test
1124 public void testGetIssueRelation() {
1125 IssueRelation issueRelation = issueService.getIssueRelation(1);
1126 assertNotNull(issueRelation);
1127 assertNotNull("issue", issueRelation.getIssue());
1128 assertNotNull("related issue", issueRelation.getRelatedIssue());
1129 assertEquals("issue 1", new Integer(1), issueRelation.getIssue().getId());
1130 assertEquals("issue 2", new Integer(2), issueRelation.getRelatedIssue().getId());
1131
1132 }
1133
1134
1135 @Override
1136 public void onSetUp() throws Exception {
1137
1138 super.onSetUp();
1139 this.issueService = (IssueService) applicationContext
1140 .getBean("issueService");
1141
1142 this.userDAO = (UserDAO) applicationContext.getBean("userDAO");
1143 this.issueDAO = (IssueDAO) applicationContext.getBean("issueDAO");
1144 this.issueRelationDAO = (IssueRelationDAO) applicationContext.getBean("issueRelationDAO");
1145 this.issueHistoryDAO = (IssueHistoryDAO) applicationContext.getBean("issueHistoryDAO");
1146 this.issueHistoryDAO = (IssueHistoryDAO) applicationContext.getBean("issueHistoryDAO");
1147 this.issueAttachmentDAO = (IssueAttachmentDAO) applicationContext.getBean("issueAttachmentDAO");
1148
1149 }
1150
1151 protected String[] getDataSetFiles() {
1152 return new String[]{"dataset/userpreferencesbean_dataset.xml",
1153 "dataset/userbean_dataset.xml",
1154 "dataset/customfieldbean_dataset.xml",
1155 "dataset/customfieldvaluebean_dataset.xml",
1156 "dataset/projectbean_dataset.xml",
1157 "dataset/projectbean_field_rel_dataset.xml",
1158 "dataset/versionbean_dataset.xml",
1159 "dataset/permissionbean_dataset.xml",
1160 "dataset/issuebean_dataset.xml",
1161 "dataset/issuefieldbean_dataset.xml",
1162 "dataset/issueattachmentbean_dataset.xml",
1163 "dataset/issueactivitybean_dataset.xml",
1164 "dataset/issuehistorybean_dataset.xml",
1165 "dataset/notificationbean_dataset.xml",
1166 "dataset/componentbean_dataset.xml",
1167 "dataset/issue_component_rel_dataset.xml",
1168 "dataset/issue_version_rel_dataset.xml",
1169 "dataset/issuerelationbean_dataset.xml",
1170 };
1171 }
1172
1173 protected String[] getConfigLocations() {
1174 return new String[]{"application-context.xml"};
1175 }
1176
1177
1178 }