1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.kuali.student.enrollment.class1.lui.service.impl;
18
19 import static org.junit.Assert.assertEquals;
20 import static org.junit.Assert.assertFalse;
21 import static org.junit.Assert.assertNotNull;
22 import static org.junit.Assert.assertTrue;
23 import static org.junit.Assert.fail;
24
25 import java.util.ArrayList;
26 import java.util.Calendar;
27 import java.util.Date;
28 import java.util.HashMap;
29 import java.util.Iterator;
30 import java.util.List;
31
32 import javax.annotation.Resource;
33
34 import org.junit.Before;
35 import org.junit.Test;
36 import org.junit.runner.RunWith;
37 import org.kuali.rice.core.api.criteria.GenericQueryResults;
38 import org.kuali.rice.core.api.criteria.PredicateFactory;
39 import org.kuali.rice.core.api.criteria.QueryByCriteria;
40 import org.kuali.student.enrollment.class1.lui.dao.LuiDao;
41 import org.kuali.student.enrollment.class1.lui.dao.LuiLuiRelationDao;
42 import org.kuali.student.enrollment.class1.lui.dao.LuiSetDao;
43 import org.kuali.student.enrollment.class1.lui.model.LuiEntity;
44 import org.kuali.student.enrollment.lui.dto.LuiIdentifierInfo;
45 import org.kuali.student.enrollment.lui.dto.LuiInfo;
46 import org.kuali.student.enrollment.lui.dto.LuiLuiRelationInfo;
47 import org.kuali.student.enrollment.lui.dto.LuiSetInfo;
48 import org.kuali.student.enrollment.lui.service.LuiService;
49 import org.kuali.student.r2.common.criteria.CriteriaLookupService;
50 import org.kuali.student.r2.common.dto.AttributeInfo;
51 import org.kuali.student.r2.common.dto.ContextInfo;
52 import org.kuali.student.r2.common.dto.RichTextInfo;
53 import org.kuali.student.r2.common.dto.StatusInfo;
54 import org.kuali.student.r2.common.exceptions.DoesNotExistException;
55 import org.kuali.student.r2.common.util.constants.LuiServiceConstants;
56 import org.kuali.student.r2.lum.clu.dto.LuCodeInfo;
57 import org.springframework.test.context.ContextConfiguration;
58 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
59 import org.springframework.test.context.transaction.TransactionConfiguration;
60 import org.springframework.transaction.annotation.Transactional;
61
62 @RunWith(SpringJUnit4ClassRunner.class)
63 @ContextConfiguration(locations = {"classpath:lui-test-context.xml"})
64 @TransactionConfiguration(transactionManager = "JtaTxManager", defaultRollback = true)
65 @Transactional
66 public class TestLuiServiceImpl {
67
68 @Resource(name = "LuiService")
69 private LuiService luiService;
70
71 @Resource(name = "luiDao")
72 private LuiDao luiDao;
73
74 @Resource(name = "luiSetDao")
75 private LuiSetDao luiSetDao;
76
77 @Resource(name= "criteriaLookupService")
78 private CriteriaLookupService criteriaLookupService;
79
80
81 public LuiLuiRelationDao getLuiLuiRelationDao() {
82 return luiLuiRelationDao;
83 }
84
85 public void setLuiLuiRelationDao(LuiLuiRelationDao luiLuiRelationDao) {
86 this.luiLuiRelationDao = luiLuiRelationDao;
87 }
88
89 @Resource(name = "luiLuiRelationDao")
90 private LuiLuiRelationDao luiLuiRelationDao;
91
92 public LuiService getLuiService() {
93 return luiService;
94 }
95
96 public void setLuiService(LuiService luiService) {
97 this.luiService = luiService;
98 }
99
100 public LuiDao getLuiDao() {
101 return luiDao;
102 }
103
104 public void setLuiDao(LuiDao luiDao) {
105 this.luiDao = luiDao;
106 }
107
108 public LuiSetDao getLuiSetDao() {
109 return luiSetDao;
110 }
111
112 public void setLuiSetDao(LuiSetDao luiSetDao) {
113 this.luiSetDao = luiSetDao;
114 }
115
116 public static String principalId = "123";
117 public ContextInfo callContext = null;
118
119 @Before
120 public void setUp() {
121 principalId = "123";
122 callContext = new ContextInfo();
123 callContext.setPrincipalId(principalId);
124 try {
125 new LuiTestDataLoader(luiDao, luiLuiRelationDao).loadData();
126 } catch (Exception ex) {
127 throw new RuntimeException (ex);
128 }
129 }
130
131 @Test
132 public void testLuiServiceSetup() {
133 assertNotNull(luiService);
134 }
135
136 @Test
137 public void testGetLui() throws Exception {
138
139 try {
140 luiService.getLui("Lui-blah", callContext);
141 fail("should not exist");
142 } catch (DoesNotExistException ex) {
143
144 }
145
146 LuiInfo obj = luiService.getLui("Lui-1", callContext);
147 assertNotNull(obj);
148 assertEquals("Lui one", obj.getName());
149 assertEquals(LuiServiceConstants.LUI_DRAFT_STATE_KEY, obj.getStateKey());
150 assertEquals(LuiServiceConstants.COURSE_OFFERING_TYPE_KEY, obj.getTypeKey());
151
152 assertEquals("Lui Desc 101", obj.getDescr().getPlain());
153
154 assertTrue(obj.getResultValuesGroupKeys().contains("Lu-Rvgr-Lui-1"));
155
156 assertNotNull(obj.getOfficialIdentifier());
157 assertEquals("Chem 123", obj.getOfficialIdentifier().getShortName());
158 assertNotNull(obj.getAlternateIdentifiers());
159 assertEquals("LUI-IDENT-2", obj.getAlternateIdentifiers().get(0).getId());
160
161 assertNotNull(obj.getEffectiveDate());
162
163 assertEquals("cluId1", obj.getCluId());
164 assertEquals("atpId1", obj.getAtpId());
165 assertEquals(1, obj.getLuiCodes().size());
166 assertEquals("Lu-Code-Lui-1", obj.getLuiCodes().get(0).getId());
167
168 assertNotNull(obj.getMaximumEnrollment());
169 assertEquals(200, obj.getMaximumEnrollment().intValue());
170 assertNotNull(obj.getMinimumEnrollment());
171 assertEquals(50, obj.getMinimumEnrollment().intValue());
172 assertEquals("ref.url", obj.getReferenceURL());
173
174
175 HashMap<String, String> attributes = new HashMap<String, String>();
176 for (AttributeInfo attributeInfo:obj.getAttributes()){
177 attributes.put(attributeInfo.getKey(), attributeInfo.getValue());
178 }
179 assertTrue(attributes.containsKey("attr1"));
180 assertTrue(attributes.containsKey("attr2"));
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201 }
202
203 @Test
204 public void testGetLuiIdsByRelation() throws Exception {
205 try {
206 List<String> luiIds = luiService.getLuiIdsByRelatedLuiAndRelationType("Lui-2", "kuali.lui.lui.relation.associated", callContext);
207 assertNotNull(luiIds);
208 assertEquals(2, luiIds.size());
209 assertEquals("Lui-1", luiIds.get(0));
210 assertEquals("Lui-5", luiIds.get(1));
211 } catch (Exception e) {
212 fail(e.getMessage());
213 }
214 }
215
216 @Test
217
218 public void testGetLuisByRelation() throws Exception {
219 try {
220 List<LuiInfo> luis = luiService.getLuisByRelatedLuiAndRelationType("Lui-2", "kuali.lui.lui.relation.associated", callContext);
221 assertNotNull(luis);
222 assertEquals(2, luis.size());
223 assertEquals("Lui-1", luis.get(0).getId());
224 assertEquals("Lui-5", luis.get(1).getId());
225 } catch (Exception e) {
226 e.printStackTrace();
227 fail(e.getMessage());
228 }
229 }
230
231
232 @Test
233 public void testGenericLookup() throws Exception {
234 QueryByCriteria.Builder qbcBuilder = QueryByCriteria.Builder.create();
235 qbcBuilder.setPredicates(PredicateFactory.like("luiType", "kuali.lui.type.course.offering"));
236 QueryByCriteria criteria = qbcBuilder.build();
237
238 try{
239 ArrayList<String> fields = new ArrayList<String>();
240 fields.add("name");
241 GenericQueryResults<List<String>> results = criteriaLookupService.genericLookup(LuiEntity.class, criteria, fields);
242 Iterator it = results.getResults().iterator();
243 while(it.hasNext()) {
244 assertTrue(it.next() instanceof String);
245 }
246
247 fields.add("luiType");
248 results = criteriaLookupService.genericLookup(LuiEntity.class, criteria, fields);
249 it = results.getResults().iterator();
250 while(it.hasNext()) {
251 Object[] result = (Object[])it.next();
252 int length = result.length;
253 String[] resultsString = new String[length];
254 for (int i = 0; i < length; i++) {
255 resultsString[i] = result[i].toString();
256 }
257 assertTrue(length==2);
258 }
259 } catch (Exception e){
260 e.printStackTrace();
261 fail(e.getMessage());
262 }
263
264 }
265
266 @Test
267 public void testCreateLui() throws Exception {
268 LuiInfo orig = new LuiInfo();
269 orig.setName("Test lui one");
270 orig.setStateKey(LuiServiceConstants.LUI_DRAFT_STATE_KEY);
271 orig.setTypeKey(LuiServiceConstants.COURSE_OFFERING_TYPE_KEY);
272 RichTextInfo rtInfo = new RichTextInfo();
273 rtInfo.setFormatted("<p>Test lui one description</p>");
274 rtInfo.setPlain("Test lui one description");
275 orig.setDescr(rtInfo);
276 orig.setEffectiveDate(Calendar.getInstance().getTime());
277 orig.setMaximumEnrollment(25);
278 orig.setMinimumEnrollment(10);
279 orig.setReferenceURL("ref.create.url");
280
281 orig.getResultValuesGroupKeys().add("Rvgr-2");
282
283 LuiIdentifierInfo identifier = new LuiIdentifierInfo();
284 identifier.setShortName("identifier.shortname");
285 identifier.setTypeKey(LuiServiceConstants.LUI_IDENTIFIER_OFFICIAL_TYPE_KEY);
286 identifier.setStateKey(LuiServiceConstants.LUI_IDENTIFIER_ACTIVE_STATE_KEY);
287 orig.setOfficialIdentifier(identifier);
288
289 LuiIdentifierInfo identifier2 = new LuiIdentifierInfo();
290 identifier2.setShortName("alternate.identifier.shortname");
291 identifier2.setTypeKey(LuiServiceConstants.LUI_IDENTIFIER_CROSSLISTED_TYPE_KEY);
292 identifier2.setStateKey(LuiServiceConstants.LUI_IDENTIFIER_ACTIVE_STATE_KEY);
293 orig.getAlternateIdentifiers().add(identifier2);
294
295 orig.setCluId("testCluId");
296 orig.setAtpId("testAtpId1");
297
298 List<String> unitsContentOwner = new ArrayList<String>();
299 unitsContentOwner.add("Org-2");
300 orig.setUnitsContentOwner(unitsContentOwner);
301
302 List<String> unitsDeployment = new ArrayList<String>();
303 unitsDeployment.add("Org-1");
304 orig.setUnitsDeployment(unitsDeployment);
305
306 List<String> resultValueGroupKeys = new ArrayList<String>();
307 resultValueGroupKeys.add("Val-Group-3");
308 orig.setResultValuesGroupKeys(resultValueGroupKeys);
309
310 LuCodeInfo luCode = new LuCodeInfo();
311 RichTextInfo rt = new RichTextInfo();
312 rt.setPlain("fee.plain");
313 rt.setFormatted("fee.formatted");
314 luCode.setDescr(rt);
315 orig.getLuiCodes().add(luCode);
316
317 LuiInfo info = luiService.createLui(orig.getCluId(), orig.getAtpId(), orig.getTypeKey(), orig, callContext);
318 assertNotNull(info);
319 assertEquals(orig.getName(), info.getName());
320 assertEquals(orig.getStateKey(), info.getStateKey());
321 assertEquals(orig.getTypeKey(), info.getTypeKey());
322 assertEquals(orig.getEffectiveDate(), info.getEffectiveDate());
323 assertEquals(orig.getExpirationDate(), info.getExpirationDate());
324
325 assertNotNull(info.getOfficialIdentifier());
326 assertEquals(orig.getOfficialIdentifier().getShortName(), info.getOfficialIdentifier().getShortName());
327 assertEquals(orig.getAlternateIdentifiers().size(), info.getAlternateIdentifiers().size());
328 assertEquals(orig.getAlternateIdentifiers().get(0).getShortName(), info.getAlternateIdentifiers().get(0).getShortName());
329
330 assertEquals(orig.getMaximumEnrollment(), info.getMaximumEnrollment());
331 assertEquals(orig.getMinimumEnrollment(), info.getMinimumEnrollment());
332 assertEquals(orig.getCluId(), info.getCluId());
333 assertEquals(orig.getAtpId(), info.getAtpId());
334 assertEquals(orig.getReferenceURL(), info.getReferenceURL());
335
336 assertTrue(info.getUnitsContentOwner().contains("Org-2"));
337 assertTrue(info.getUnitsDeployment().contains("Org-1"));
338 assertTrue(info.getResultValuesGroupKeys().contains("Val-Group-3"));
339
340 assertEquals(1, info.getLuiCodes().size());
341
342 info = luiService.getLui(info.getId(), callContext);
343 assertNotNull(info);
344 assertEquals(orig.getName(), info.getName());
345 assertEquals(orig.getStateKey(), info.getStateKey());
346 assertEquals(orig.getTypeKey(), info.getTypeKey());
347 assertEquals(orig.getEffectiveDate(), info.getEffectiveDate());
348 assertEquals(orig.getExpirationDate(), info.getExpirationDate());
349
350 assertNotNull(info.getOfficialIdentifier());
351 assertEquals(orig.getOfficialIdentifier().getShortName(), info.getOfficialIdentifier().getShortName());
352 assertEquals(orig.getAlternateIdentifiers().size(), info.getAlternateIdentifiers().size());
353 assertEquals(orig.getAlternateIdentifiers().get(0).getShortName(), info.getAlternateIdentifiers().get(0).getShortName());
354
355 assertEquals(orig.getMaximumEnrollment(), info.getMaximumEnrollment());
356 assertEquals(orig.getMinimumEnrollment(), info.getMinimumEnrollment());
357 assertEquals(orig.getCluId(), info.getCluId());
358 assertEquals(orig.getAtpId(), info.getAtpId());
359 assertEquals(orig.getReferenceURL(), info.getReferenceURL());
360 }
361
362 @Test
363 public void testGetLuisByAtpAndClu() throws Exception{
364 List<LuiInfo> luis = luiService.getLuisByAtpAndClu("cluId1", "atpId1", callContext) ;
365 assertTrue(luis.size()>0);
366 assertNotNull(luis);
367 assertEquals(1, luis.size());
368 LuiInfo onlyLui = luis.get(0);
369 assertNotNull(onlyLui);
370 assertEquals("Lui-1", onlyLui.getId() );
371 assertEquals("Lui one", onlyLui.getName());
372 assertEquals("cluId1", onlyLui.getCluId());
373 assertEquals("atpId1", onlyLui.getAtpId());
374 }
375
376 @Test
377 public void testUpdateLui() throws Exception {
378 LuiInfo info = luiService.getLui("Lui-1", callContext);
379 assertNotNull(info);
380 assertEquals("Lui-1", info.getId());
381 assertEquals("Lui one", info.getName());
382
383 LuiInfo modified = new LuiInfo(info);
384 modified.setName("Lui one modified");
385 modified.setStateKey(LuiServiceConstants.LUI_AO_STATE_APPROVED_KEY);
386 modified.setMaximumEnrollment(25);
387 modified.setMinimumEnrollment(10);
388 assertNotNull(modified.getOfficialIdentifier());
389 modified.getOfficialIdentifier().setTypeKey(LuiServiceConstants.LUI_IDENTIFIER_OFFICIAL_TYPE_KEY);
390 modified.getOfficialIdentifier().setStateKey(LuiServiceConstants.LUI_IDENTIFIER_ACTIVE_STATE_KEY);
391 modified.getOfficialIdentifier().setShortName("identifier.shortname");
392
393 modified.getAlternateIdentifiers().clear();
394 LuiIdentifierInfo identifier2 = new LuiIdentifierInfo();
395 identifier2.setShortName("alternate.identifier.shortname");
396 identifier2.setTypeKey(LuiServiceConstants.LUI_IDENTIFIER_CROSSLISTED_TYPE_KEY);
397 identifier2.setStateKey(LuiServiceConstants.LUI_IDENTIFIER_ACTIVE_STATE_KEY);
398 modified.getAlternateIdentifiers().add(identifier2);
399
400 modified.setReferenceURL("ref.update.url");
401 modified.setCluId("updateCluId");
402 modified.setAtpId("updateAtpId1");
403
404 modified.getResultValuesGroupKeys().add("Val-Group-11");
405
406
407 List<AttributeInfo> attributes = new ArrayList<AttributeInfo>();
408 for (AttributeInfo attrInfo:modified.getAttributes()){
409 if (attrInfo.getKey().equals("attr2")){
410 attributes.add(attrInfo);
411 }
412 }
413 AttributeInfo modAttr1 = new AttributeInfo();
414 modAttr1.setKey("modattr1");
415 modAttr1.setValue("modattr1");
416 attributes.add(modAttr1);
417
418 AttributeInfo modAttr2 = new AttributeInfo();
419 modAttr2.setKey("modattr2");
420 modAttr2.setValue("modattr2");
421 attributes.add(modAttr2);
422 modified.setAttributes(attributes);
423
424 LuCodeInfo luCode = new LuCodeInfo();
425 RichTextInfo rt = new RichTextInfo();
426 rt.setPlain("fee.plain");
427 rt.setFormatted("fee.formatted");
428 luCode.setDescr(rt);
429 luCode.setId("Modified Lu Code");
430 modified.getLuiCodes().clear();
431 modified.getLuiCodes().add(luCode);
432
433 modified.getUnitsContentOwner().add("Org-22");
434
435 modified.getUnitsDeployment().add("Org-11");
436
437 LuiInfo updated = luiService.updateLui("Lui-1", modified, callContext);
438
439 assertNotNull(updated);
440 assertEquals("Lui one modified", updated.getName());
441 assertEquals(LuiServiceConstants.LUI_AO_STATE_APPROVED_KEY, updated.getStateKey());
442 assertEquals(LuiServiceConstants.COURSE_OFFERING_TYPE_KEY, updated.getTypeKey());
443 assertEquals(Integer.valueOf(25), updated.getMaximumEnrollment());
444 assertEquals(Integer.valueOf(10), updated.getMinimumEnrollment());
445 assertEquals("ref.update.url", updated.getReferenceURL());
446 assertNotNull(updated.getEffectiveDate());
447
448 assertEquals(2, updated.getResultValuesGroupKeys().size());
449 assertTrue(updated.getResultValuesGroupKeys().contains("Val-Group-11"));
450
451 assertNotNull(updated.getOfficialIdentifier());
452 assertEquals("identifier.shortname", updated.getOfficialIdentifier().getShortName());
453 assertEquals(1, updated.getAlternateIdentifiers().size());
454 assertEquals("alternate.identifier.shortname", updated.getAlternateIdentifiers().get(0).getShortName());
455
456
457 HashMap<String, String> updatedAttributes = new HashMap<String, String>();
458 for (AttributeInfo attributeInfo:updated.getAttributes()){
459 updatedAttributes.put(attributeInfo.getKey(), attributeInfo.getValue());
460 }
461 assertFalse(updatedAttributes.containsKey("attr1"));
462 assertTrue(updatedAttributes.containsKey("attr2"));
463 assertTrue(updatedAttributes.containsKey("modattr1"));
464 assertTrue(updatedAttributes.containsKey("modattr2"));
465
466 assertTrue(updated.getUnitsContentOwner().contains("Org-22"));
467 assertTrue(updated.getUnitsDeployment().contains("Org-11"));
468
469 assertEquals(1, info.getLuiCodes().size());
470 assertEquals("Lu-Code-Lui-1", info.getLuiCodes().get(0).getId());
471 assertEquals(1, updated.getLuiCodes().size());
472 assertEquals("Modified Lu Code", updated.getLuiCodes().get(0).getId());
473 }
474
475 @Test
476 public void testUpdateLuiLuiRelation() throws Exception{
477 LuiLuiRelationInfo info = luiService.getLuiLuiRelation("LUILUIREL-2", callContext);
478 assertNotNull(info);
479 info.setStateKey(LuiServiceConstants.LUI_LUI_RELATION_INACTIVE_STATE_KEY);
480 luiService.updateLuiLuiRelation(info.getId(), info, callContext);
481 assertEquals(info.getStateKey(), LuiServiceConstants.LUI_LUI_RELATION_INACTIVE_STATE_KEY);
482 }
483
484 @Test
485 public void testGetLuiLuiRelation() throws Exception {
486 try {
487 LuiLuiRelationInfo obj = luiService.getLuiLuiRelation("LUILUIREL-1", callContext);
488 assertNotNull(obj);
489 assertEquals("Lui-1", obj.getLuiId());
490 assertEquals("Lui-2", obj.getRelatedLuiId());
491
492 } catch (Exception ex) {
493 fail("exception from service call :" + ex.getMessage());
494 }
495 }
496
497 @Test
498 public void testGetLuiLuiRelationsByLui() throws Exception {
499
500 luiService.getLuiLuiRelationsByLui("Lui-Lui-Blah", callContext);
501 List<LuiLuiRelationInfo> objs = luiService.getLuiLuiRelationsByLui("Lui-1", callContext);
502 assertNotNull(objs);
503 assertEquals(1, objs.size());
504 }
505
506 @Test
507 public void testCreateLuiLuiRelation() throws Exception{
508 LuiInfo info = new LuiInfo();
509 info.setCluId("testCluId");
510 info.setAtpId("testAtpId1");
511 info.setName("Test lui-Lui relation");
512 info.setStateKey(LuiServiceConstants.LUI_DRAFT_STATE_KEY);
513 info.setTypeKey(LuiServiceConstants.LAB_ACTIVITY_OFFERING_TYPE_KEY);
514 info.setEffectiveDate(Calendar.getInstance().getTime());
515 info.setMaximumEnrollment(25);
516 info.setMinimumEnrollment(10);
517 RichTextInfo rtInfo = new RichTextInfo();
518 rtInfo.setFormatted("<p>Test lui-Lui relation description</p>");
519 rtInfo.setPlain("Test lui-Lui relation description");
520 info.setDescr(rtInfo);
521
522 LuiInfo newLui = luiService.createLui(info.getCluId(), info.getAtpId(), info.getTypeKey(), info, callContext);
523 LuiLuiRelationInfo created = null;
524 LuiLuiRelationInfo rel = new LuiLuiRelationInfo();
525 rel.setLuiId("Lui-1");
526 rel.setRelatedLuiId(newLui.getId());
527 rel.setStateKey(LuiServiceConstants.LUI_LUI_RELATION_ACTIVE_STATE_KEY);
528 rel.setTypeKey(LuiServiceConstants.LUI_LUI_RELATION_DELIVERED_VIA_FO_TO_AO_TYPE_KEY);
529 rel.setEffectiveDate(Calendar.getInstance().getTime());
530 rtInfo = new RichTextInfo();
531 rtInfo.setFormatted("<p>Test lui-Lui relation description</p>");
532 rtInfo.setPlain("Test lui-Lui relation description");
533 rel.setDescr(rtInfo);
534 created = luiService.createLuiLuiRelation("Lui-1", newLui.getId(), LuiServiceConstants.LUI_LUI_RELATION_DELIVERED_VIA_FO_TO_AO_TYPE_KEY, rel, callContext);
535
536 assertNotNull(created);
537 assertEquals(LuiServiceConstants.LUI_LUI_RELATION_ACTIVE_STATE_KEY, created.getStateKey());
538 assertEquals(LuiServiceConstants.LUI_LUI_RELATION_DELIVERED_VIA_FO_TO_AO_TYPE_KEY, created.getTypeKey());
539
540
541
542 LuiLuiRelationInfo retrieved = luiService.getLuiLuiRelation(created.getId(), callContext);
543 assertNotNull(retrieved);
544 assertEquals(LuiServiceConstants.LUI_LUI_RELATION_ACTIVE_STATE_KEY, retrieved.getStateKey());
545 assertEquals(LuiServiceConstants.LUI_LUI_RELATION_DELIVERED_VIA_FO_TO_AO_TYPE_KEY, retrieved.getTypeKey());
546
547 List<LuiLuiRelationInfo> objs = luiService.getLuiLuiRelationsByLui("Lui-1", callContext);
548 assertNotNull(objs);
549 assertEquals(2, objs.size());
550 for (LuiLuiRelationInfo obj : objs) {
551 assertTrue(obj.getRelatedLuiId().equals("Lui-2") || obj.getRelatedLuiId().equals(newLui.getId()));
552 }
553 }
554
555 @Test
556 public void testDeleteLui()
557 throws Exception{
558 LuiInfo info = luiService.getLui("Lui-3", callContext);
559 assertNotNull(info);
560
561 List<LuiLuiRelationInfo> objs = luiService.getLuiLuiRelationsByLui("Lui-3", callContext);
562 assertNotNull(objs);
563 assertEquals(1, objs.size());
564
565 try {
566 luiService.deleteLui("Lui-3-blah", callContext);
567 } catch (DoesNotExistException ee) {
568 }
569
570 StatusInfo status = luiService.deleteLui("Lui-3", callContext);
571 assertTrue(status.getIsSuccess());
572
573 luiService.getLuiLuiRelationsByLui("Lui-3", callContext);
574
575 try {
576 luiService.getLui("Lui-3", callContext);
577 } catch (DoesNotExistException ee) {
578 }
579 }
580
581 @Test
582 public void testGetLuisByIds() throws Exception {
583 List<String> luiIds = new ArrayList<String>();
584 luiIds.add("Lui-1");
585 luiIds.add("Lui-2");
586 luiIds.add("Lui-3");
587 List<LuiInfo> luis = luiService.getLuisByIds(luiIds, callContext);
588
589 assertNotNull(luis);
590 assertTrue(luis.size() == 3);
591
592 try{
593 luiIds.add("Lui-3b");
594 luis = luiService.getLuisByIds(luiIds, callContext);
595 }catch (DoesNotExistException ex) {
596 assertNotNull(ex.getMessage());
597 }
598
599 }
600
601
602
603 @Test
604 public void testGetLuiIdsByType() throws Exception {
605
606 List<String> luis = luiService.getLuiIdsByType("kuali.lui.type.course.offering", callContext);
607
608 assertNotNull(luis);
609 assertTrue(luis.size() == 2);
610
611 }
612
613
614 @Test
615 public void testGetLuiIdsByAtpAndType() throws Exception{
616 List<String> luiIds = luiService.getLuiIdsByAtpAndType( "atpId1", "kuali.lui.type.course.offering", callContext);
617 assertNotNull(luiIds);
618 assertEquals(luiIds.size(), 1);
619 assertEquals(luiIds.get(0) ,"Lui-1");
620 List<String> luiIdsNonExistent = luiService.getLuiIdsByAtpAndType( "atpId21", "kuali.lui.type.course.offering", callContext);
621 assertNotNull(luiIdsNonExistent);
622 assertEquals(luiIdsNonExistent.size(),0);
623
624 }
625 @Test
626 public void testGetRelatedLuiIdsByLui() throws Exception{
627 List<String> luiRelationIds = luiService.getLuiIdsByLuiAndRelationType("Lui-1", "kuali.lui.lui.relation.associated", callContext);
628 assertNotNull(luiRelationIds);
629 assertEquals( 1, luiRelationIds.size());
630 assertEquals("Lui-2", luiRelationIds.get(0) );
631
632 }
633 @Test
634 public void testGetRelatedLuisByLui() throws Exception{
635 List<LuiInfo> luiRelations = luiService.getRelatedLuisByLuiAndRelationType("Lui-3", "kuali.lui.lui.relation.associated", callContext);
636 assertNotNull(luiRelations);
637 assertEquals( 1, luiRelations.size());
638 assertEquals("Lui-4", luiRelations.get(0).getId() );
639
640 }
641
642 private LuiSetInfo createLuiSetInfo(){
643 LuiSetInfo luiSetInfo = new LuiSetInfo();
644 luiSetInfo.setName("Lui Set");
645 luiSetInfo.setTypeKey(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY);
646 luiSetInfo.setStateKey(LuiServiceConstants.LUI_SET_ACTIVE_STATE_KEY);
647 luiSetInfo.getLuiIds().add("Lui-1");
648 luiSetInfo.getLuiIds().add("Lui-2");
649 RichTextInfo descr = new RichTextInfo();
650 descr.setPlain("test");
651 luiSetInfo.setDescr(descr);
652 AttributeInfo attributeInfo = new AttributeInfo();
653 attributeInfo.setKey("test.key");
654 attributeInfo.setValue("test.value");
655 luiSetInfo.getAttributes().add(attributeInfo);
656 luiSetInfo.setEffectiveDate(new Date());
657 luiSetInfo.setExpirationDate(new Date());
658 return luiSetInfo;
659 }
660
661 @Test
662 public void testCreateLuiSet() throws Exception {
663
664 LuiSetInfo luiSetInfo = createLuiSetInfo();
665
666 LuiSetInfo newLuiSet = luiService.createLuiSet(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY,luiSetInfo,callContext);
667
668 assertNotNull(newLuiSet);
669 assertNotNull(newLuiSet.getId());
670 assertEquals(luiSetInfo.getName(),newLuiSet.getName());
671 assertEquals(luiSetInfo.getTypeKey(),newLuiSet.getTypeKey());
672 assertEquals(luiSetInfo.getStateKey(),newLuiSet.getStateKey());
673 assertEquals(luiSetInfo.getDescr().getPlain(),newLuiSet.getDescr().getPlain());
674 assertEquals(2,newLuiSet.getLuiIds().size());
675 assertEquals(1,newLuiSet.getAttributes().size());
676
677 newLuiSet = luiService.getLuiSet(newLuiSet.getId(), callContext);
678 assertNotNull(newLuiSet);
679 assertNotNull(newLuiSet.getId());
680 assertEquals(luiSetInfo.getName(),newLuiSet.getName());
681 assertEquals(luiSetInfo.getTypeKey(),newLuiSet.getTypeKey());
682 assertEquals(luiSetInfo.getStateKey(),newLuiSet.getStateKey());
683 assertEquals(luiSetInfo.getDescr().getPlain(),newLuiSet.getDescr().getPlain());
684 assertEquals(2,newLuiSet.getLuiIds().size());
685 }
686
687 @Test
688 public void testUpdateLuiSet() throws Exception {
689 LuiSetInfo luiSetInfo1 = createLuiSetInfo();
690
691 LuiSetInfo newLuiSet = luiService.createLuiSet(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY,luiSetInfo1,callContext);
692 assertNotNull(newLuiSet);
693
694 newLuiSet.setName("UpdateName");
695 newLuiSet.getLuiIds().add("Lui-3");
696 LuiSetInfo luiSetInfo2 = luiService.updateLuiSet(newLuiSet.getId(),newLuiSet,callContext);
697 assertNotNull(luiSetInfo2);
698 assertEquals(3,luiSetInfo2.getLuiIds().size());
699
700 LuiSetInfo luiSetInfo3 = luiService.getLuiSet(luiSetInfo2.getId(),callContext);
701 assertNotNull(luiSetInfo3);
702 assertEquals(luiSetInfo2.getName(),luiSetInfo3.getName());
703 assertEquals(luiSetInfo2.getTypeKey(),luiSetInfo3.getTypeKey());
704 assertEquals(luiSetInfo2.getStateKey(),luiSetInfo3.getStateKey());
705 assertEquals(luiSetInfo2.getDescr().getPlain(), luiSetInfo3.getDescr().getPlain());
706 assertEquals(3,luiSetInfo3.getLuiIds().size());
707
708 luiSetInfo3.getLuiIds().remove(0);
709 luiSetInfo3.getLuiIds().remove(1);
710 LuiSetInfo luiSetInfo4 = luiService.updateLuiSet(luiSetInfo3.getId(),luiSetInfo3,callContext);
711 assertNotNull(luiSetInfo4);
712 assertEquals(1,luiSetInfo4.getLuiIds().size());
713
714 }
715
716 @Test
717 public void testDeleteLuiSet() throws Exception {
718 LuiSetInfo luiSetInfo = createLuiSetInfo();
719 LuiSetInfo newLuiSet = luiService.createLuiSet(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY,luiSetInfo,callContext);
720 assertNotNull(newLuiSet);
721
722 StatusInfo statusInfo = luiService.deleteLuiSet(newLuiSet.getId(),callContext);
723 assertTrue(statusInfo.getIsSuccess());
724
725 }
726
727 @Test
728 public void testGetLuiSetsByLui() throws Exception{
729 LuiSetInfo luiSetInfo = createLuiSetInfo();
730 LuiSetInfo newLuiSet = luiService.createLuiSet(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY,luiSetInfo,callContext);
731 assertNotNull(newLuiSet);
732
733 List<LuiSetInfo> luiSetInfos = luiService.getLuiSetsByLui("Lui-1",callContext);
734 assertEquals(1,luiSetInfos.size());
735
736 luiSetInfos = luiService.getLuiSetsByLui("Lui-5",callContext);
737 assertEquals(0,luiSetInfos.size());
738 }
739
740 @Test
741 public void testGetLuiSetIdsByType() throws Exception{
742 LuiSetInfo luiSetInfo = createLuiSetInfo();
743 LuiSetInfo newLuiSet = luiService.createLuiSet(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY,luiSetInfo,callContext);
744 assertNotNull(newLuiSet);
745
746 List<String> luiSetIdsByType = luiService.getLuiSetIdsByType(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY, callContext);
747 assertEquals(1,luiSetIdsByType.size());
748
749 luiSetIdsByType = luiService.getLuiSetIdsByType("test.type.invalid",callContext);
750 assertEquals(0,luiSetIdsByType.size());
751 }
752
753 @Test
754 public void testGetLuiIdsFromLuiSet() throws Exception{
755 LuiSetInfo luiSetInfo = createLuiSetInfo();
756 LuiSetInfo newLuiSet = luiService.createLuiSet(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY,luiSetInfo,callContext);
757 assertNotNull(newLuiSet);
758
759 List<String> luiIds = luiService.getLuiIdsFromLuiSet(newLuiSet.getId(),callContext);
760 assertEquals(2,luiIds.size());
761 }
762
763 @Test
764 public void testGetLuiSetsByIds() throws Exception{
765 LuiSetInfo luiSetInfo = createLuiSetInfo();
766 LuiSetInfo newLuiSet1 = luiService.createLuiSet(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY,luiSetInfo,callContext);
767 assertNotNull(newLuiSet1);
768
769 luiSetInfo = createLuiSetInfo();
770 LuiSetInfo newLuiSet2 = luiService.createLuiSet(LuiServiceConstants.LUI_SET_COLOCATED_OFFERING_TYPE_KEY,luiSetInfo,callContext);
771 assertNotNull(newLuiSet2);
772
773 List<String> luiSetIds = new ArrayList<String>();
774 luiSetIds.add(newLuiSet1.getId());
775 luiSetIds.add(newLuiSet2.getId());
776
777 List<LuiSetInfo> luiSetInfos = luiService.getLuiSetsByIds(luiSetIds,callContext);
778 assertEquals(2,luiSetInfos.size());
779 }
780
781 }