View Javadoc
1   /*
2    * To change this template, choose Tools | Templates
3    * and open the template in the editor.
4    */
5   package org.itracker.model.util;
6   
7   import org.itracker.AbstractDependencyInjectionTest;
8   import org.itracker.model.*;
9   import org.itracker.model.CustomField.Type;
10  import org.junit.Test;
11  
12  import java.text.SimpleDateFormat;
13  import java.util.*;
14  
15  /**
16   * TODO: make tests using the database where appropriat (setup testdata from datasets)
17   *
18   * @author seas at andreysergievskiy.com
19   */
20  public class IssueUtilitiesIT extends AbstractDependencyInjectionTest {
21  
22      @Test
23      public void testGetFieldType() {
24          assertEquals(IssueUtilities.FIELD_TYPE_SINGLE,
25                  IssueUtilities.getFieldType(IssueUtilities.FIELD_ID));
26          assertEquals(IssueUtilities.FIELD_TYPE_SINGLE,
27                  IssueUtilities.getFieldType(IssueUtilities.FIELD_DESCRIPTION));
28          assertEquals(IssueUtilities.FIELD_TYPE_MAP,
29                  IssueUtilities.getFieldType(1)); // custom field
30  
31      }
32  
33      @Test
34      public void testGetFieldName() {
35          assertEquals("id",
36                  IssueUtilities.getFieldName(IssueUtilities.FIELD_ID));
37          assertEquals("description",
38                  IssueUtilities.getFieldName(IssueUtilities.FIELD_DESCRIPTION));
39          assertEquals("status",
40                  IssueUtilities.getFieldName(IssueUtilities.FIELD_STATUS));
41          assertEquals("resolution",
42                  IssueUtilities.getFieldName(IssueUtilities.FIELD_RESOLUTION));
43          assertEquals("severity",
44                  IssueUtilities.getFieldName(IssueUtilities.FIELD_SEVERITY));
45          assertEquals("creatorId",
46                  IssueUtilities.getFieldName(IssueUtilities.FIELD_CREATOR));
47          assertEquals("createdate",
48                  IssueUtilities.getFieldName(IssueUtilities.FIELD_CREATEDATE));
49          assertEquals("ownerId",
50                  IssueUtilities.getFieldName(IssueUtilities.FIELD_OWNER));
51          assertEquals("lastmodified",
52                  IssueUtilities.getFieldName(IssueUtilities.FIELD_LASTMODIFIED));
53          assertEquals("projectId",
54                  IssueUtilities.getFieldName(IssueUtilities.FIELD_PROJECT));
55          assertEquals("targetVersion",
56                  IssueUtilities.getFieldName(IssueUtilities.FIELD_TARGET_VERSION));
57          assertEquals("components",
58                  IssueUtilities.getFieldName(IssueUtilities.FIELD_COMPONENTS));
59          assertEquals("versions",
60                  IssueUtilities.getFieldName(IssueUtilities.FIELD_VERSIONS));
61          assertEquals("attachmentDescription",
62                  IssueUtilities.getFieldName(IssueUtilities.FIELD_ATTACHMENTDESCRIPTION));
63          assertEquals("attachment",
64                  IssueUtilities.getFieldName(IssueUtilities.FIELD_ATTACHMENTFILENAME));
65          assertEquals("history",
66                  IssueUtilities.getFieldName(IssueUtilities.FIELD_HISTORY));
67          assertEquals("",
68                  IssueUtilities.getFieldName(null));
69          assertEquals("",
70                  IssueUtilities.getFieldName(-999));
71          assertEquals("customFields",
72                  IssueUtilities.getFieldName(999));
73      }
74  
75      @Test
76      public void testGetFieldNameByLocale() {
77          final List<CustomField> customFields = new Vector<CustomField>();
78          final CustomField customField1 = new CustomField();
79          customField1.setFieldType(Type.STRING);
80          customField1.setId(1);
81          customFields.add(customField1);
82          assertEquals("test-field_custom",
83                  IssueUtilities.getFieldName(1, customFields, new Locale("test")));
84      }
85  
86      @Test
87      public void testGetStandardFieldKey() {
88          assertEquals("itracker.web.attr.id",
89                  IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_ID));
90          assertEquals("itracker.web.attr.description",
91                  IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_DESCRIPTION));
92          assertEquals("itracker.web.attr.status",
93                  IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_STATUS));
94          assertEquals("itracker.web.attr.resolution",
95                  IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_RESOLUTION));
96          assertEquals("itracker.web.attr.severity",
97                  IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_SEVERITY));
98          assertEquals("itracker.web.attr.creator",
99                  IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_CREATOR));
100         assertEquals("itracker.web.attr.createdate",
101                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_CREATEDATE));
102         assertEquals("itracker.web.attr.owner",
103                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_OWNER));
104         assertEquals("itracker.web.attr.lastmodified",
105                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_LASTMODIFIED));
106         assertEquals("itracker.web.attr.project",
107                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_PROJECT));
108         assertEquals("itracker.web.attr.target",
109                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_TARGET_VERSION));
110         assertEquals("itracker.web.attr.components",
111                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_COMPONENTS));
112         assertEquals("itracker.web.attr.versions",
113                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_VERSIONS));
114         assertEquals("itracker.web.attr.attachmentdescription",
115                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_ATTACHMENTDESCRIPTION));
116         assertEquals("itracker.web.attr.attachmentfilename",
117                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_ATTACHMENTFILENAME));
118         assertEquals("itracker.web.attr.detaileddescription",
119                 IssueUtilities.getStandardFieldKey(IssueUtilities.FIELD_HISTORY));
120         assertEquals("itracker.web.generic.unknown",
121                 IssueUtilities.getStandardFieldKey(-999));
122         assertEquals("itracker.web.generic.unknown",
123                 IssueUtilities.getStandardFieldKey(999));
124     }
125 
126     public void doTestGetStandardFields(final Locale locale,
127                                         final NameValuePair[] expected) {
128         final NameValuePair[] actual = IssueUtilities.getStandardFields(locale);
129         for (final NameValuePair nvpExpected : expected) {
130             boolean found = false;
131             for (final NameValuePair nvpActual : actual) {
132                 found = nvpExpected.getName().equals(nvpActual.getName())
133                         && nvpExpected.getValue().equals(nvpActual.getValue());
134                 if (found) break;
135             }
136             assertTrue("IssueUtilities.getStandardFields(" + locale + ").contains(" +
137                     "new NameValuePair(" + nvpExpected.getName() + "," +
138                     nvpExpected.getValue() + "))",
139                     found);
140         }
141         assertEquals("IssueUtilities.getStandardFields(" + locale + ").length",
142                 expected.length, actual.length);
143     }
144 
145     @Test
146     public void testGetStandardFields() {
147         final NameValuePair[] expected = new NameValuePair[]{
148                 new NameValuePair("test-field_id",
149                         Integer.toString(IssueUtilities.FIELD_ID)),
150                 new NameValuePair("test-field_description",
151                         Integer.toString(IssueUtilities.FIELD_DESCRIPTION)),
152                 new NameValuePair("test-field_status",
153                         Integer.toString(IssueUtilities.FIELD_STATUS)),
154                 new NameValuePair("test-field_resolution",
155                         Integer.toString(IssueUtilities.FIELD_RESOLUTION)),
156                 new NameValuePair("test-field_severity",
157                         Integer.toString(IssueUtilities.FIELD_SEVERITY)),
158                 new NameValuePair("test-field_creator",
159                         Integer.toString(IssueUtilities.FIELD_CREATOR)),
160                 new NameValuePair("test-field_createdate",
161                         Integer.toString(IssueUtilities.FIELD_CREATEDATE)),
162                 new NameValuePair("test-field_owner",
163                         Integer.toString(IssueUtilities.FIELD_OWNER)),
164                 new NameValuePair("test-field_lastmodified",
165                         Integer.toString(IssueUtilities.FIELD_LASTMODIFIED)),
166                 new NameValuePair("test-field_project",
167                         Integer.toString(IssueUtilities.FIELD_PROJECT)),
168                 new NameValuePair("test-field_target",
169                         Integer.toString(IssueUtilities.FIELD_TARGET_VERSION)),
170                 new NameValuePair("test-field_components",
171                         Integer.toString(IssueUtilities.FIELD_COMPONENTS)),
172                 new NameValuePair("test-field_versions",
173                         Integer.toString(IssueUtilities.FIELD_VERSIONS)),
174                 new NameValuePair("test-field_attachmentdescription",
175                         Integer.toString(IssueUtilities.FIELD_ATTACHMENTDESCRIPTION)),
176                 new NameValuePair("test-field_attachmentfilename",
177                         Integer.toString(IssueUtilities.FIELD_ATTACHMENTFILENAME)),
178                 new NameValuePair("test-field_detaileddescription",
179                         Integer.toString(IssueUtilities.FIELD_HISTORY))
180         };
181         doTestGetStandardFields(new Locale("test"), expected);
182     }
183 
184     @Test
185     public void testGetRelationNameByLocaleWithInt() {
186         assertEquals("test-cloned_c",
187                 IssueUtilities.getRelationName(
188                         IssueRelation.Type.CLONED_C,
189                         new Locale("test")));
190         assertEquals("test-cloned_p",
191                 IssueUtilities.getRelationName(
192                         IssueRelation.Type.CLONED_P,
193                         new Locale("test")));
194         assertEquals("test-dependent_c",
195                 IssueUtilities.getRelationName(
196                         IssueRelation.Type.DEPENDENT_C,
197                         new Locale("test")));
198         assertEquals("test-dependent_p",
199                 IssueUtilities.getRelationName(
200                         IssueRelation.Type.DEPENDENT_P,
201                         new Locale("test")));
202         assertEquals("test-duplicate_c",
203                 IssueUtilities.getRelationName(
204                         IssueRelation.Type.DUPLICATE_C,
205                         new Locale("test")));
206         assertEquals("test-duplicate_p",
207                 IssueUtilities.getRelationName(
208                         IssueRelation.Type.DUPLICATE_P,
209                         new Locale("test")));
210         assertEquals("test-related_c",
211                 IssueUtilities.getRelationName(
212                         IssueRelation.Type.RELATED_C,
213                         new Locale("test")));
214         assertEquals("test-related_p",
215                 IssueUtilities.getRelationName(
216                         IssueRelation.Type.RELATED_P,
217                         new Locale("test")));
218         assertEquals("test-split_c",
219                 IssueUtilities.getRelationName(
220                         IssueRelation.Type.SPLIT_C,
221                         new Locale("test")));
222         assertEquals("test-split_p",
223                 IssueUtilities.getRelationName(
224                         IssueRelation.Type.SPLIT_P,
225                         new Locale("test")));
226     }
227 
228 
229     @Test
230     public void testGetMatchingRelationType() {
231         assertEquals(IssueRelation.Type.RELATED_C,
232                 IssueUtilities.getMatchingRelationType(
233                         IssueRelation.Type.RELATED_P));
234         assertEquals(IssueRelation.Type.RELATED_P,
235                 IssueUtilities.getMatchingRelationType(
236                         IssueRelation.Type.RELATED_C));
237         assertEquals(IssueRelation.Type.DUPLICATE_C,
238                 IssueUtilities.getMatchingRelationType(
239                         IssueRelation.Type.DUPLICATE_P));
240         assertEquals(IssueRelation.Type.DUPLICATE_P,
241                 IssueUtilities.getMatchingRelationType(
242                         IssueRelation.Type.DUPLICATE_C));
243         assertEquals(IssueRelation.Type.CLONED_C,
244                 IssueUtilities.getMatchingRelationType(
245                         IssueRelation.Type.CLONED_P));
246         assertEquals(IssueRelation.Type.CLONED_P,
247                 IssueUtilities.getMatchingRelationType(
248                         IssueRelation.Type.CLONED_C));
249         assertEquals(IssueRelation.Type.SPLIT_C,
250                 IssueUtilities.getMatchingRelationType(
251                         IssueRelation.Type.SPLIT_P));
252         assertEquals(IssueRelation.Type.SPLIT_P,
253                 IssueUtilities.getMatchingRelationType(
254                         IssueRelation.Type.SPLIT_C));
255         assertEquals(IssueRelation.Type.DEPENDENT_C,
256                 IssueUtilities.getMatchingRelationType(
257                         IssueRelation.Type.DEPENDENT_P));
258         assertEquals(IssueRelation.Type.DEPENDENT_P,
259                 IssueUtilities.getMatchingRelationType(
260                         IssueRelation.Type.DEPENDENT_C));
261     }
262 
263     @Test
264     public void testComponentsToString() {
265         final Issue issue = new Issue();
266         final Project project = new Project("project");
267         {
268             final Component component = new Component(project, "component1");
269             issue.getComponents().add(component);
270         }
271         {
272             final Component component = new Component(project, "component2");
273             issue.getComponents().add(component);
274         }
275         assertEquals("component1, component2",
276                 IssueUtilities.componentsToString(issue));
277     }
278 
279     @Test
280     public void testVersionsToString() {
281         final Issue issue = new Issue();
282         issue.getVersions().add(new Version(new Project("project"), "1.1.1"));
283         issue.getVersions().add(new Version(new Project("project"), "1.2.3"));
284         issue.getVersions().add(new Version(new Project("project"), "3.2.1"));
285         assertEquals("1.1.1, 1.2.3, 3.2.1",
286                 IssueUtilities.versionsToString(issue));
287     }
288 
289     @Test
290     public void testHistoryToString() {
291         final Issue issue = new Issue();
292         final User user = new User("user");
293         user.setFirstName("firstName");
294         user.setLastName("lastName");
295         final IssueHistory issueHistory = new IssueHistory(issue,
296                 user, "description", IssueUtilities.STATUS_CLOSED);
297         issue.getHistory().add(issueHistory);
298         final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
299         assertEquals("description,firstName lastName,"
300                 + dateFormat.format(new Date()),
301                 IssueUtilities.historyToString(issue,
302                         dateFormat));
303     }
304 
305     @Test
306     public void testGetStatusNameByLocaleInt() {
307         assertEquals("test-status_assigned",
308                 IssueUtilities.getStatusName(IssueUtilities.STATUS_ASSIGNED,
309                         new Locale("test")));
310         assertEquals("test-status_closed",
311                 IssueUtilities.getStatusName(IssueUtilities.STATUS_CLOSED,
312                         new Locale("test")));
313         assertEquals("test-status_end",
314                 IssueUtilities.getStatusName(IssueUtilities.STATUS_END,
315                         new Locale("test")));
316         assertEquals("test-status_new",
317                 IssueUtilities.getStatusName(IssueUtilities.STATUS_NEW,
318                         new Locale("test")));
319         assertEquals("test-status_resolved",
320                 IssueUtilities.getStatusName(IssueUtilities.STATUS_RESOLVED,
321                         new Locale("test")));
322         assertEquals("test-status_unassigned",
323                 IssueUtilities.getStatusName(IssueUtilities.STATUS_UNASSIGNED,
324                         new Locale("test")));
325     }
326 
327     public void doTestGetStatusesByLocale(final Locale locale,
328                                           final List<NameValuePair> expected) {
329         assertEquals(expected.size(), IssueUtilities.getNumberStatuses());
330         final List<NameValuePair> actual = IssueUtilities.getStatuses(locale);
331         assertEquals(expected.size(), actual.size());
332         for (final NameValuePair nvpExpected : expected) {
333             boolean found = false;
334             for (final NameValuePair nvpActual : actual) {
335                 found = nvpExpected.getName().equals(nvpActual.getName())
336                         && nvpExpected.getValue().equals(nvpActual.getValue());
337                 if (found) break;
338             }
339             assertTrue(found);
340         }
341     }
342 
343     @Test
344     public void testGetStatusesByLocale() {
345         final List<NameValuePair> expected = new Vector<NameValuePair>();
346         expected.add(new NameValuePair("test-status_new", "100"));
347         expected.add(new NameValuePair("test-status_unassigned", "200"));
348         expected.add(new NameValuePair("test-status_assigned", "300"));
349         expected.add(new NameValuePair("test-status_resolved", "400"));
350         expected.add(new NameValuePair("test-status_closed", "500"));
351 //        expected.add(new NameValuePair("test-status_end", "600"));
352         doTestGetStatusesByLocale(new Locale("test"), expected);
353     }
354 
355     @Test
356     public void testSetStatuses() {
357         final List<Configuration> statuses_ = IssueUtilities.getStatuses();
358         final List<Configuration> statuses = new Vector<Configuration>();
359         final Configuration configuration = new Configuration(Configuration.Type.status,
360                 new NameValuePair("key", "100"));
361         statuses.add(configuration);
362         IssueUtilities.setStatuses(statuses);
363         final List<NameValuePair> expected = new Vector<NameValuePair>();
364         expected.add(new NameValuePair("test-status_new", "100"));
365         doTestGetStatusesByLocale(new Locale("test"), expected);
366 
367     }
368 
369     @Test
370     public void testGetNumberStatuses() {
371 
372         assertEquals(5, IssueUtilities.getNumberStatuses());
373     }
374 
375     @Test
376     public void testGetSeverityNameByLocale() {
377         assertEquals("test-severity_low",
378                 IssueUtilities.getSeverityName(1, new Locale("test")));
379         assertEquals("test-severity_middle",
380                 IssueUtilities.getSeverityName(2, new Locale("test")));
381         assertEquals("test-severity_high",
382                 IssueUtilities.getSeverityName(3, new Locale("test")));
383         assertEquals("test-severity_critical",
384                 IssueUtilities.getSeverityName(4, new Locale("test")));
385     }
386 
387     public void doTestGetSeverities(final Locale locale,
388                                     final List<NameValuePair> expected) {
389         final List<NameValuePair> actual = IssueUtilities.getSeverities(locale);
390         assertEquals(expected.size(), actual.size());
391         for (final NameValuePair nvpExpected : expected) {
392             boolean found = false;
393             for (final NameValuePair nvpActual : actual) {
394                 found = nvpExpected.getName().equals(nvpActual.getName())
395                         && nvpExpected.getValue().equals(nvpActual.getValue());
396                 if (found) break;
397             }
398             assertTrue(found);
399         }
400     }
401 
402     @Test
403     public void testGetSeverities() {
404         final List<Configuration> severities = new Vector<Configuration>();
405         final Configuration severity1 = new Configuration(Configuration.Type.severity,
406                 new NameValuePair("1", "1"));
407         severities.add(severity1);
408         final Configuration severity2 = new Configuration(Configuration.Type.severity,
409                 new NameValuePair("2", "2"));
410         severities.add(severity2);
411         final Configuration severity3 = new Configuration(Configuration.Type.severity,
412                 new NameValuePair("3", "3"));
413         severities.add(severity3);
414         final Configuration severity4 = new Configuration(Configuration.Type.severity,
415                 new NameValuePair("4", "4"));
416         severities.add(severity4);
417         IssueUtilities.setSeverities(severities);
418         final List<NameValuePair> expected = new Vector<NameValuePair>();
419         expected.add(new NameValuePair("test-severity_low", "1"));
420         expected.add(new NameValuePair("test-severity_middle", "2"));
421         expected.add(new NameValuePair("test-severity_high", "3"));
422         expected.add(new NameValuePair("test-severity_critical", "4"));
423         doTestGetSeverities(new Locale("test"), expected);
424     }
425 
426     @Test
427     public void testSetSeverities() {
428         final List<Configuration> severities = new Vector<Configuration>();
429         final Configuration severity = new Configuration(Configuration.Type.severity,
430                 new NameValuePair("88", "1"));
431         severities.add(severity);
432         IssueUtilities.setSeverities(severities);
433         final List<NameValuePair> expected = new Vector<NameValuePair>();
434         expected.add(new NameValuePair("test-severity_low", "1"));
435         doTestGetSeverities(new Locale("test"), expected);
436     }
437 
438     @Test
439     public void testCompareSeverities() {
440         final Issue issueA = new Issue();
441         issueA.setSeverity(1);
442         final Issue issueB = new Issue();
443         issueB.setSeverity(2);
444         assertEquals(1, IssueUtilities.compareSeverity(issueA, issueB));
445     }
446 
447     @Test
448     public void testGetResolutionName() {
449         assertEquals("test-resolution_fixed",
450                 IssueUtilities.getResolutionName(1, new Locale("test")));
451         assertEquals("test-resolution_pending",
452                 IssueUtilities.getResolutionName(2, new Locale("test")));
453     }
454 
455     @Test
456     public void testCheckResolutionName() {
457         assertEquals("test-resolution_fixed",
458                 IssueUtilities.checkResolutionName("1", new Locale("test")));
459         assertEquals("test-resolution_pending",
460                 IssueUtilities.checkResolutionName("2", new Locale("test")));
461     }
462 
463     public void doTestGetResolutionsByLocale(final Locale locale,
464                                              final List<NameValuePair> expected) {
465         final List<NameValuePair> actual = IssueUtilities.getResolutions(locale);
466         assertEquals(expected.size(), actual.size());
467         for (final NameValuePair nvpExpected : expected) {
468             boolean found = false;
469             for (final NameValuePair nvpActual : actual) {
470                 found = nvpExpected.getName().equals(nvpActual.getName())
471                         && nvpExpected.getValue().equals(nvpActual.getValue());
472             }
473             assertTrue(found);
474         }
475     }
476 
477     @Test
478     public void testGetResolutionsByLocale() {
479         final List<Configuration> resolutions = new Vector<Configuration>();
480         final Configuration resolution = new Configuration(Configuration.Type.resolution,
481                 new NameValuePair("one", "1"));
482         resolutions.add(resolution);
483         IssueUtilities.setResolutions(resolutions);
484         final List<NameValuePair> expected = new Vector<NameValuePair>();
485         expected.add(new NameValuePair("test-resolution_fixed", "1"));
486         doTestGetResolutionsByLocale(new Locale("test"), expected);
487     }
488 
489     @Test
490     public void testSetResolutions() {
491         final List<Configuration> resolutions = new Vector<Configuration>();
492         final Configuration resolution = new Configuration(Configuration.Type.resolution,
493                 new NameValuePair("key", "1"));
494         resolutions.add(resolution);
495         IssueUtilities.setResolutions(resolutions);
496         final List<NameValuePair> expected = new Vector<NameValuePair>();
497         expected.add(new NameValuePair("test-resolution_fixed", "1"));
498         doTestGetResolutionsByLocale(new Locale("test"), expected);
499     }
500 
501     @Test
502     public void testGetActivityNameByLocale() {
503         assertEquals("test-activity_issue_created",
504                 IssueUtilities.getActivityName(IssueActivityType.ISSUE_CREATED,
505                         new Locale("test")));
506 
507     }
508 
509     public void doTestGetCustomFields(final List<CustomField> expected) {
510         final List<CustomField> actual = IssueUtilities.getCustomFields();
511         assertEquals(expected.size(), actual.size());
512         for (final CustomField cf : expected) {
513             boolean found = false;
514             for (final CustomField cfActual : actual) {
515                 found = cf.equals(cfActual);
516                 if (found) break;
517             }
518             assertTrue(found);
519         }
520     }
521 
522     @Test
523     public void testGetCustomFields() {
524         final List<CustomField> expected = new Vector<CustomField>();
525         final CustomField customField1 = new CustomField();
526         customField1.setFieldType(Type.STRING);
527         customField1.setId(1);
528         expected.add(customField1);
529         IssueUtilities.setCustomFields(expected);
530         doTestGetCustomFields(expected);
531     }
532 
533     @Test
534     public void testSetCustomFields() {
535         final List<CustomField> expected = new Vector<CustomField>();
536         final CustomField customField1 = new CustomField();
537         customField1.setFieldType(Type.STRING);
538         customField1.setId(1);
539         expected.add(customField1);
540         IssueUtilities.setCustomFields(expected);
541         assertEquals(expected, IssueUtilities.getCustomFields());
542     }
543 
544 
545     @Test
546     public void testCanViewIssue() {
547         final Project project = new Project("project");
548         project.setId(1);
549         final Issue issue = new Issue();
550         issue.setProject(project);
551         final User user1 = new User();
552         user1.setId(1);
553         issue.setCreator(user1);
554         final User user2 = new User();
555         user2.setId(2);
556         final Map<Integer, Set<PermissionType>> permissions =
557                 new HashMap<Integer, Set<PermissionType>>();
558         assertTrue(IssueUtilities.canViewIssue(issue, user1, permissions));
559         assertFalse(IssueUtilities.canViewIssue(issue, user2, permissions));
560         final Set<PermissionType> permissionSet = new HashSet<PermissionType>();
561         permissionSet.add(PermissionType.ISSUE_VIEW_ALL);
562         permissions.put(1, permissionSet);
563         assertTrue(IssueUtilities.canViewIssue(issue, user2, permissions));
564     }
565 
566     @Test
567     public void testCanEditIssue() {
568         final Project project = new Project("project");
569         project.setId(1);
570         final Issue issue = new Issue();
571         issue.setProject(project);
572         final User user1 = new User();
573         user1.setId(1);
574         issue.setCreator(user1);
575         final User user2 = new User();
576         user2.setId(2);
577         final Map<Integer, Set<PermissionType>> permissions =
578                 new HashMap<Integer, Set<PermissionType>>();
579         final Set<PermissionType> permissionSet = new HashSet<PermissionType>();
580         permissions.put(1, permissionSet);
581         permissionSet.add(PermissionType.ISSUE_EDIT_USERS);
582         assertTrue(IssueUtilities.canEditIssue(issue, user1.getId(), permissions));
583         assertFalse(IssueUtilities.canEditIssue(issue, user2.getId(), permissions));
584         permissionSet.add(PermissionType.ISSUE_EDIT_ALL);
585         assertTrue(IssueUtilities.canEditIssue(issue, user1.getId(), permissions));
586         assertTrue(IssueUtilities.canEditIssue(issue, user2.getId(), permissions));
587     }
588 
589     @Test
590     public void testCanBeAssignedIssue() {
591         final Project project = new Project("project");
592         project.setId(1);
593         final Issue issue = new Issue();
594         issue.setProject(project);
595         final Integer user1Id = 1;
596         final Integer user2Id = 2;
597         final Map<Integer, Set<PermissionType>> permissions =
598                 new HashMap<Integer, Set<PermissionType>>();
599         final Set<PermissionType> permissionSet = new HashSet<PermissionType>();
600         permissionSet.add(PermissionType.ISSUE_ASSIGNABLE);
601         permissionSet.add(PermissionType.ISSUE_EDIT_ALL);
602         permissions.put(1, permissionSet);
603         assertTrue(IssueUtilities.canBeAssignedIssue(issue, user1Id, permissions));
604         assertTrue(IssueUtilities.canBeAssignedIssue(issue, user2Id, permissions));
605     }
606 
607     @Test
608     public void testCanUnassigneIssue() {
609         final Project project = new Project("project");
610         project.setId(1);
611         final Issue issue = new Issue();
612         issue.setProject(project);
613         final User user1 = new User();
614         user1.setId(1);
615         issue.setOwner(user1);
616         final User user2 = new User();
617         user2.setId(2);
618         final Map<Integer, Set<PermissionType>> permissions =
619                 new HashMap<Integer, Set<PermissionType>>();
620         final Set<PermissionType> permissionSet = new HashSet<PermissionType>();
621         permissionSet.add(PermissionType.ISSUE_UNASSIGN_SELF);
622         permissions.put(1, permissionSet);
623         assertTrue(IssueUtilities.canUnassignIssue(issue, user1.getId(), permissions));
624         assertFalse(IssueUtilities.canUnassignIssue(issue, user2.getId(), permissions));
625     }
626 
627     @Test
628     public void testHasIssueRelation() {
629         final Project project = new Project("project");
630         project.setId(1);
631         final Issue issue = new Issue();
632         final Issue related = new Issue();
633         related.setId(1);
634         final IssueRelation relation =
635                 new IssueRelation(issue, related,
636                         IssueRelation.Type.CLONED_C);
637         issue.getRelations().add(relation);
638         assertTrue(IssueUtilities.hasIssueRelation(issue, 1));
639         assertFalse(IssueUtilities.hasIssueRelation(issue, 2));
640     }
641 
642     @Test
643     public void testHasIssueNotification() {
644         final Project project = new Project("project");
645         project.setId(1);
646         final Issue issue = new Issue();
647         issue.setId(1);
648         issue.setProject(project);
649         final User user1 = new User();
650         user1.setId(1);
651         issue.setCreator(user1);
652         issue.setOwner(user1);
653         assertTrue(IssueUtilities.hasIssueNotification(issue, 1));
654         //assertFalse(IssueUtilities.hasIssueNotification(issue, 2));
655     }
656 
657     @Override
658     public void onSetUp() throws Exception {
659 
660         super.onSetUp();
661     }
662 
663     /**
664      * Defines a set of datafiles to be uploaded into database.
665      *
666      * @return an array with datafiles.
667      */
668     protected String[] getDataSetFiles() {
669         return new String[]{
670                 "dataset/languagebean_dataset.xml"
671         };
672     }
673 
674     /**
675      * Defines a simple configuration, required for running tests.
676      *
677      * @return an array of references to configuration files.
678      */
679     protected String[] getConfigLocations() {
680         return new String[]{"application-context.xml"};
681     }
682 }