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