1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.student.lum.lu.service.impl;
17
18 import static org.junit.Assert.assertEquals;
19 import static org.junit.Assert.assertFalse;
20 import static org.junit.Assert.assertNotNull;
21 import static org.junit.Assert.assertNull;
22 import static org.junit.Assert.assertTrue;
23 import static org.junit.Assert.fail;
24
25 import java.text.ParseException;
26 import java.text.SimpleDateFormat;
27 import java.util.ArrayList;
28 import java.util.Arrays;
29 import java.util.Comparator;
30 import java.util.Date;
31 import java.util.List;
32
33 import org.apache.log4j.Logger;
34 import org.junit.Assert;
35 import org.junit.Test;
36 import org.kuali.student.common.dto.AmountInfo;
37 import org.kuali.student.common.dto.CurrencyAmountInfo;
38 import org.kuali.student.common.dto.RichTextInfo;
39 import org.kuali.student.common.dto.StatusInfo;
40 import org.kuali.student.common.dto.TimeAmountInfo;
41 import org.kuali.student.common.exceptions.AlreadyExistsException;
42 import org.kuali.student.common.exceptions.CircularRelationshipException;
43 import org.kuali.student.common.exceptions.DataValidationErrorException;
44 import org.kuali.student.common.exceptions.DependentObjectsExistException;
45 import org.kuali.student.common.exceptions.DoesNotExistException;
46 import org.kuali.student.common.exceptions.IllegalVersionSequencingException;
47 import org.kuali.student.common.exceptions.InvalidParameterException;
48 import org.kuali.student.common.exceptions.MissingParameterException;
49 import org.kuali.student.common.exceptions.OperationFailedException;
50 import org.kuali.student.common.exceptions.PermissionDeniedException;
51 import org.kuali.student.common.exceptions.UnsupportedActionException;
52 import org.kuali.student.common.exceptions.VersionMismatchException;
53 import org.kuali.student.common.search.dto.SearchParam;
54 import org.kuali.student.common.search.dto.SearchRequest;
55 import org.kuali.student.common.search.dto.SearchResult;
56 import org.kuali.student.common.search.dto.SearchResultCell;
57 import org.kuali.student.common.search.dto.SearchResultRow;
58 import org.kuali.student.common.test.spring.AbstractServiceTest;
59 import org.kuali.student.common.test.spring.Client;
60 import org.kuali.student.common.test.spring.Dao;
61 import org.kuali.student.common.test.spring.Daos;
62 import org.kuali.student.common.test.spring.PersistenceFileLocation;
63 import org.kuali.student.common.validation.dto.ValidationResultInfo;
64 import org.kuali.student.common.versionmanagement.dto.VersionDisplayInfo;
65 import org.kuali.student.lum.lu.dto.AccreditationInfo;
66 import org.kuali.student.lum.lu.dto.AdminOrgInfo;
67 import org.kuali.student.lum.lu.dto.AffiliatedOrgInfo;
68 import org.kuali.student.lum.lu.dto.CluAccountingInfo;
69 import org.kuali.student.lum.lu.dto.CluCluRelationInfo;
70 import org.kuali.student.lum.lu.dto.CluFeeInfo;
71 import org.kuali.student.lum.lu.dto.CluFeeRecordInfo;
72 import org.kuali.student.lum.lu.dto.CluIdentifierInfo;
73 import org.kuali.student.lum.lu.dto.CluInfo;
74 import org.kuali.student.lum.lu.dto.CluInstructorInfo;
75 import org.kuali.student.lum.lu.dto.CluLoRelationInfo;
76 import org.kuali.student.lum.lu.dto.CluPublicationInfo;
77 import org.kuali.student.lum.lu.dto.CluResultInfo;
78 import org.kuali.student.lum.lu.dto.CluSetInfo;
79 import org.kuali.student.lum.lu.dto.CluSetTreeViewInfo;
80 import org.kuali.student.lum.lu.dto.FieldInfo;
81 import org.kuali.student.lum.lu.dto.LuCodeInfo;
82 import org.kuali.student.lum.lu.dto.LuLuRelationTypeInfo;
83 import org.kuali.student.lum.lu.dto.LuiInfo;
84 import org.kuali.student.lum.lu.dto.LuiLuiRelationInfo;
85 import org.kuali.student.lum.lu.dto.MembershipQueryInfo;
86 import org.kuali.student.lum.lu.dto.ResultOptionInfo;
87 import org.kuali.student.lum.lu.dto.ResultUsageTypeInfo;
88 import org.kuali.student.lum.lu.service.LuService;
89 import org.kuali.student.lum.lu.service.LuServiceConstants;
90
91 import edu.emory.mathcs.backport.java.util.Collections;
92
93 @Daos( { @Dao(value = "org.kuali.student.lum.lu.dao.impl.LuDaoImpl", testSqlFile = "classpath:ks-lu.sql"
94
95
96
97
98 ) })
99 @PersistenceFileLocation("classpath:META-INF/lu-persistence.xml")
100 public class TestLuServiceImpl extends AbstractServiceTest {
101 @Client(value = "org.kuali.student.lum.lu.service.impl.LuServiceImpl", additionalContextFile = "classpath:lu-additional-context.xml")
102 public LuService client;
103 private static final SimpleDateFormat DF = new SimpleDateFormat("yyyyMMdd");
104 final Logger LOG = Logger.getLogger(TestLuServiceImpl.class);
105
106 @Test
107 public void testClu() throws DoesNotExistException,
108 InvalidParameterException, MissingParameterException,
109 OperationFailedException {
110
111 CluInfo clu = client.getClu("CLU-1");
112 assertNotNull(clu);
113 assertEquals(clu.getId(), "CLU-1");
114
115 try {
116 clu = client.getClu("CLX-1");
117 assertTrue(false);
118 } catch (DoesNotExistException e) {
119 assertTrue(true);
120 }
121
122 try {
123 clu = client.getClu(null);
124 assertTrue(false);
125 } catch (MissingParameterException e) {
126 assertTrue(true);
127 }
128
129
130 List<String> ids = new ArrayList<String>(1);
131 ids.add("CLU-2");
132 List<CluInfo> clus = client.getClusByIdList(ids);
133 assertNotNull(clus);
134 assertEquals(1, clus.size());
135
136 ids.clear();
137 ids.add("CLX-42");
138 clus = client.getClusByIdList(ids);
139 assertTrue(clus == null || clus.size() == 0);
140
141 try {
142 clus = client.getClusByIdList(null);
143 assertTrue(false);
144 } catch (MissingParameterException e) {
145 assertTrue(true);
146 }
147
148
149 ids = client.getCluIdsByLuType("luType.shell.program", "STATE2");
150 assertTrue(null != ids);
151 assertEquals(1, ids.size());
152 assertEquals("CLU-2", ids.get(0));
153
154 ids = client.getCluIdsByLuType("LUTYPE-1X", "STATE1");
155 assertTrue(ids == null || ids.size() == 0);
156 ids = client.getCluIdsByLuType("luType.shell.course", "STATE1X");
157 assertTrue(ids == null || ids.size() == 0);
158
159 try {
160 ids = client.getCluIdsByLuType(null, "STATE1");
161 assertTrue(false);
162 } catch (MissingParameterException e) {
163 assertTrue(true);
164 }
165
166 try {
167 ids = client.getCluIdsByLuType("luType.shell.course", null);
168 assertTrue(false);
169 } catch (MissingParameterException e) {
170 assertTrue(true);
171 }
172
173
174 clus = client.getClusByLuType("luType.shell.program", "STATE2");
175 assertTrue(null != clus);
176 assertEquals(1, clus.size());
177 assertEquals("CLU-2", clus.get(0).getId());
178
179 clus = client.getClusByLuType("LUTYPE-1X", "STATE1");
180 assertTrue(clus == null || clus.size() == 0);
181 clus = client.getClusByLuType("luType.shell.course", "STATE1X");
182 assertTrue(clus == null || clus.size() == 0);
183
184 try {
185 clus = client.getClusByLuType(null, "STATE1");
186 assertTrue(false);
187 } catch (MissingParameterException e) {
188 assertTrue(true);
189 }
190
191 try {
192 clus = client.getClusByLuType("luType.shell.course", null);
193 assertTrue(false);
194 } catch (MissingParameterException e) {
195 assertTrue(true);
196 }
197 }
198
199 @Test
200 public void testCluSet() throws DoesNotExistException,
201 InvalidParameterException, MissingParameterException,
202 OperationFailedException, PermissionDeniedException {
203
204 CluSetInfo csi = client.getCluSetInfo("CLUSET-2");
205 assertNotNull(csi);
206
207 csi = client.getCluSetInfo("CLUSET-1");
208 assertNotNull(csi);
209
210 try {
211 csi = client.getCluSetInfo("CLUSETXX-42");
212 assertTrue(false);
213 } catch (DoesNotExistException e1) {
214 assertTrue(true);
215 }
216
217 try {
218 csi = client.getCluSetInfo(null);
219 assertTrue(false);
220 } catch (MissingParameterException e) {
221 assertTrue(true);
222 }
223
224
225 List<String> ids = new ArrayList<String>(1);
226 ids.add("CLUSET-2");
227 List<CluSetInfo> cluSets = client.getCluSetInfoByIdList(ids);
228 assertEquals(1, cluSets.size());
229
230 ids.clear();
231 ids.add("CLUSETXXX-42");
232 cluSets = client.getCluSetInfoByIdList(ids);
233 assertTrue(cluSets == null || cluSets.size() == 0);
234
235 try {
236 cluSets = client.getCluSetInfoByIdList(null);
237 assertTrue(false);
238 } catch (MissingParameterException e) {
239 assertTrue(true);
240 }
241
242
243 ids = client.getCluIdsFromCluSet("CLUSET-2");
244 assertEquals(2, ids.size());
245 assertEquals("CLU-1", ids.get(0));
246
247 try {
248 ids = client.getCluIdsFromCluSet("CLUSETXXX-42");
249 assertTrue(false);
250 } catch (DoesNotExistException e) {
251 assertTrue(true);
252 }
253
254 try {
255 ids = client.getCluIdsFromCluSet(null);
256 assertTrue(false);
257 } catch (MissingParameterException e) {
258 assertTrue(true);
259 }
260
261
262 List<CluInfo> clus = client.getClusFromCluSet("CLUSET-2");
263 assertEquals(2, clus.size());
264 assertEquals("CLU-1", clus.get(0).getId());
265
266 try {
267 clus = client.getClusFromCluSet("CLUSETXXX-42");
268 assertTrue(false);
269 } catch (DoesNotExistException e) {
270 assertTrue(true);
271 }
272
273 try {
274 clus = client.getClusFromCluSet(null);
275 assertTrue(false);
276 } catch (MissingParameterException e) {
277 assertTrue(true);
278 }
279
280 clus = client.getAllClusInCluSet("CLUSET-4");
281 assertEquals(2, clus.size());
282
283 try {
284 ids = client.getAllCluIdsInCluSet(null);
285 assertTrue(false);
286 } catch (MissingParameterException e) {
287 assertTrue(true);
288 }
289
290 clus = client.getAllClusInCluSet("CLUSET-2");
291 assertEquals(3, clus.size());
292
293
294 Boolean inSet = client.isCluInCluSet("CLU-2", "CLUSET-4");
295 assertTrue(inSet);
296
297 inSet = client.isCluInCluSet("CLU-3", "CLUSET-4");
298 assertTrue(inSet);
299
300 inSet = client.isCluInCluSet("CLUXX-42", "CLUSET-4");
301 assertFalse(inSet);
302
303 inSet = client.isCluInCluSet("CLU-2", "CLUSETXX-42");
304 assertFalse(inSet);
305
306 try {
307 inSet = client.isCluInCluSet(null, "CLUSET-4");
308 assertTrue(false);
309 } catch (MissingParameterException e) {
310 assertTrue(true);
311 }
312 try {
313 inSet = client.isCluInCluSet("CLU-2", null);
314 assertTrue(false);
315 } catch (MissingParameterException e) {
316 assertTrue(true);
317 }
318 }
319
320 @Test
321 public void testCluSetCrud() throws AlreadyExistsException,
322 DataValidationErrorException, InvalidParameterException,
323 MissingParameterException, OperationFailedException,
324 PermissionDeniedException, DoesNotExistException, ParseException,
325 VersionMismatchException, UnsupportedActionException,
326 CircularRelationshipException {
327 CluSetInfo cluSetInfo = new CluSetInfo();
328
329 RichTextInfo desc = new RichTextInfo();
330 desc.setFormatted("<p>Formatted Desc</p>");
331 desc.setPlain("plain");
332 cluSetInfo.setType("kuali.cluSet.type.CreditCourse");
333 cluSetInfo.setState ("draft");
334 cluSetInfo.setAdminOrg("uuid-1234");
335 cluSetInfo.setDescr(desc);
336 cluSetInfo.setEffectiveDate(DF.parse("20080101"));
337 cluSetInfo.setExpirationDate(DF.parse("20180101"));
338 cluSetInfo.setName("testCluSet1");
339 cluSetInfo.getCluIds().add("CLU-1");
340 cluSetInfo.getCluIds().add("CLU-2");
341
342
343 cluSetInfo.getAttributes().put("cluSet1ArrtKey1", "cluSet1ArrtValue1");
344 cluSetInfo.getAttributes().put("cluSet1ArrtKey2", "cluSet1ArrtValue2");
345
346 CluSetInfo createdSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", cluSetInfo);
347
348 assertEquals("kuali.cluSet.type.CreditCourse", createdSet1.getType());
349 assertEquals("uuid-1234", createdSet1.getAdminOrg());
350 assertEquals("<p>Formatted Desc</p>", createdSet1.getDescr().getFormatted());
351 assertEquals("plain", createdSet1.getDescr().getPlain());
352 assertEquals(DF.parse("20080101"), createdSet1.getEffectiveDate());
353 assertEquals(DF.parse("20180101"), createdSet1.getExpirationDate());
354 assertEquals("testCluSet1", createdSet1.getName());
355 assertEquals("CLU-1", createdSet1.getCluIds().get(0));
356 assertEquals("CLU-2", createdSet1.getCluIds().get(1));
357
358
359 assertEquals("cluSet1ArrtValue1", createdSet1.getAttributes().get("cluSet1ArrtKey1"));
360 assertEquals("cluSet1ArrtValue2", createdSet1.getAttributes().get("cluSet1ArrtKey2"));
361 assertNotNull(createdSet1.getMetaInfo().getCreateTime());
362 assertNotNull(createdSet1.getMetaInfo().getUpdateTime());
363 assertNotNull(createdSet1.getId());
364
365 createdSet1.setAdminOrg("uuid-1234-5678");
366 createdSet1.getDescr().setFormatted("UP<p>Formatted Desc</p>");
367 createdSet1.getDescr().setPlain("UPplain");
368 createdSet1.setEffectiveDate(DF.parse("20090101"));
369 createdSet1.setExpirationDate(DF.parse("20190101"));
370 createdSet1.setName("UPtestCluSet1");
371 createdSet1.getCluIds().remove(1);
372 createdSet1.getCluIds().add("CLU-3");
373
374
375 createdSet1.getAttributes().put("cluSet1ArrtKey1", "UPcluSet1ArrtValue1");
376 createdSet1.getAttributes().remove("cluSet1ArrtKey2");
377 createdSet1.getAttributes().put("cluSet1ArrtKey3", "cluSet1ArrtValue3");
378
379 CluSetInfo updatedSet1 = client.updateCluSet(createdSet1.getId(), createdSet1);
380
381 assertEquals("uuid-1234-5678", updatedSet1.getAdminOrg());
382 assertEquals("UP<p>Formatted Desc</p>", updatedSet1.getDescr().getFormatted());
383 assertEquals("UPplain", updatedSet1.getDescr().getPlain());
384 assertEquals(DF.parse("20090101"), updatedSet1.getEffectiveDate());
385 assertEquals(DF.parse("20190101"), updatedSet1.getExpirationDate());
386 assertEquals("UPtestCluSet1", updatedSet1.getName());
387 assertEquals("CLU-1", updatedSet1.getCluIds().get(0));
388 assertEquals("CLU-3", updatedSet1.getCluIds().get(1));
389 assertEquals(2, updatedSet1.getCluIds().size());
390
391
392
393 assertEquals("UPcluSet1ArrtValue1", updatedSet1.getAttributes().get(
394 "cluSet1ArrtKey1"));
395 assertEquals("cluSet1ArrtValue3", updatedSet1.getAttributes().get(
396 "cluSet1ArrtKey3"));
397 assertEquals(2, updatedSet1.getAttributes().size());
398 assertNotNull(updatedSet1.getMetaInfo().getUpdateTime());
399 }
400
401 @Test
402 public void testRemoveCluFromCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
403 CluSetInfo createCluSet = createCluSetInfo();
404 createCluSet.getCluIds().add("CLU-1");
405 createCluSet.getCluIds().add("CLU-2");
406 createCluSet.getCluIds().add("CLU-3");
407
408 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
409 assertEquals(3, createdCluSet1.getCluIds().size());
410
411 StatusInfo status = client.removeCluFromCluSet("CLU-2", createdCluSet1.getId());
412 assertTrue(status.getSuccess());
413
414 createdCluSet1 = client.getCluSetInfo(createdCluSet1.getId());
415
416 assertEquals(2, createdCluSet1.getCluIds().size());
417 assertTrue(createdCluSet1.getCluIds().contains("CLU-1"));
418 assertFalse(createdCluSet1.getCluIds().contains("CLU-2"));
419 assertTrue(createdCluSet1.getCluIds().contains("CLU-3"));
420 }
421
422 @Test
423 public void testRemoveCluSetFromCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
424 CluSetInfo createCluSet = createCluSetInfo();
425 createCluSet.getCluSetIds().add("CLUSET-1");
426 createCluSet.getCluSetIds().add("CLUSET-2");
427 createCluSet.getCluSetIds().add("CLUSET-3");
428
429 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
430 assertEquals(3, createdCluSet1.getCluSetIds().size());
431
432 StatusInfo status = client.removeCluSetFromCluSet(createdCluSet1.getId(), "CLUSET-2");
433 assertTrue(status.getSuccess());
434
435 createdCluSet1 = client.getCluSetInfo(createdCluSet1.getId());
436
437 assertEquals(2, createdCluSet1.getCluSetIds().size());
438 assertTrue(createdCluSet1.getCluSetIds().contains("CLUSET-1"));
439 assertFalse(createdCluSet1.getCluSetIds().contains("CLUSET-2"));
440 assertTrue(createdCluSet1.getCluSetIds().contains("CLUSET-3"));
441 }
442
443 @Test
444 public void testDeleteCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
445 CluSetInfo createCluSet = createCluSetInfo();
446
447 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
448
449 StatusInfo status = client.deleteCluSet(createdCluSet1.getId());
450 assertTrue(status.getSuccess());
451
452 try {
453 client.getCluSetInfo(createdCluSet1.getId());
454 fail("Should have thrown DoesNotExistException");
455 } catch (DoesNotExistException e) {
456 assertTrue(true);
457 }
458 }
459
460 @Test
461 public void testCluCluRelation() throws ParseException,
462 AlreadyExistsException, DataValidationErrorException,
463 DoesNotExistException, InvalidParameterException,
464 MissingParameterException, OperationFailedException,
465 PermissionDeniedException, VersionMismatchException,
466 DependentObjectsExistException {
467 List<CluCluRelationInfo> ccrs = client.getCluCluRelationsByClu("CLU-1");
468 assertNotNull(ccrs);
469 assertEquals(2, ccrs.size());
470
471 ccrs = client.getCluCluRelationsByClu("CLUXX-42");
472 assertTrue(ccrs == null || ccrs.size() == 0);
473
474 try {
475 ccrs = client.getCluCluRelationsByClu(null);
476 assertTrue(false);
477 } catch (MissingParameterException e) {
478 assertTrue(true);
479 }
480
481 }
482
483 @Test
484 public void testCluCrud() throws ParseException, AlreadyExistsException,
485 DataValidationErrorException, DoesNotExistException,
486 InvalidParameterException, MissingParameterException,
487 OperationFailedException, PermissionDeniedException,
488 VersionMismatchException, DependentObjectsExistException {
489
490 CluInfo clu = createCluInfo();
491
492 clu.getOfficialIdentifier().setCode("offId-divisionoffId-suffixcode");
493 clu.getOfficialIdentifier().getAttributes().put("OfficialIdentKey", "OfficialIdentValue");
494
495 clu.getAlternateIdentifiers().get(0).setCode("cluId1-divisioncluId1-suffixcode");
496 clu.getAlternateIdentifiers().get(0).getAttributes().put("AltIdentKey", "AltIdentValue");
497 clu.getAlternateIdentifiers().get(1).setCode("cluId2-divisioncluId2-suffixcode");
498 clu.getAlternateIdentifiers().get(1).getAttributes().put("AltIdentKey", "AltIdentValue");
499
500
501
502 CluInfo createdClu = client.createClu("luType.shell.course", clu);
503 createdClu = client.getClu(createdClu.getId());
504
505 assertNotNull(createdClu);
506
507 assertEquals("AccountingAttrValue1", createdClu.getAccountingInfo()
508 .getAttributes().get("AccountingAttrKey1"));
509 assertEquals("AccountingAttrValue2", createdClu.getAccountingInfo()
510 .getAttributes().get("AccountingAttrKey2"));
511
512 assertEquals("offId-divisionoffId-suffixcode", createdClu
513 .getOfficialIdentifier().getCode());
514 assertEquals("offId-division", createdClu.getOfficialIdentifier()
515 .getDivision());
516 assertEquals("offId-level", createdClu.getOfficialIdentifier()
517 .getLevel());
518 assertEquals("offId-longName", createdClu.getOfficialIdentifier()
519 .getLongName());
520 assertEquals("offId-shortName", createdClu.getOfficialIdentifier()
521 .getShortName());
522 assertEquals("offId-state", createdClu.getOfficialIdentifier()
523 .getState());
524 assertEquals("offId-type", createdClu.getOfficialIdentifier().getType());
525 assertEquals("offId-variation", createdClu.getOfficialIdentifier()
526 .getVariation());
527 assertEquals("offId-suffixcode", createdClu.getOfficialIdentifier()
528 .getSuffixCode());
529 assertEquals("offId-orgid", createdClu.getOfficialIdentifier()
530 .getOrgId());
531 assertEquals("OfficialIdentValue", createdClu.getOfficialIdentifier().getAttributes().get("OfficialIdentKey"));
532
533
534 assertEquals("cluId1-divisioncluId1-suffixcode", createdClu
535 .getAlternateIdentifiers().get(0).getCode());
536 assertEquals("cluId1-division", createdClu.getAlternateIdentifiers()
537 .get(0).getDivision());
538 assertEquals("cluId1-level", createdClu.getAlternateIdentifiers()
539 .get(0).getLevel());
540 assertEquals("cluId1-longName", createdClu.getAlternateIdentifiers()
541 .get(0).getLongName());
542 assertEquals("cluId1-shortName", createdClu.getAlternateIdentifiers()
543 .get(0).getShortName());
544 assertEquals("cluId1-state", createdClu.getAlternateIdentifiers()
545 .get(0).getState());
546 assertEquals("cluId1-type", createdClu.getAlternateIdentifiers().get(0)
547 .getType());
548 assertEquals("cluId1-variation", createdClu.getAlternateIdentifiers()
549 .get(0).getVariation());
550 assertEquals("cluId1-suffixcode", createdClu.getAlternateIdentifiers()
551 .get(0).getSuffixCode());
552 assertEquals("cluId1-orgid", createdClu.getAlternateIdentifiers()
553 .get(0).getOrgId());
554 assertEquals("AltIdentValue", createdClu.getAlternateIdentifiers().get(0).getAttributes().get("AltIdentKey"));
555
556
557 assertEquals("cluId2-divisioncluId2-suffixcode", createdClu
558 .getAlternateIdentifiers().get(1).getCode());
559 assertEquals("cluId2-division", createdClu.getAlternateIdentifiers()
560 .get(1).getDivision());
561 assertEquals("cluId2-level", createdClu.getAlternateIdentifiers()
562 .get(1).getLevel());
563 assertEquals("cluId2-longName", createdClu.getAlternateIdentifiers()
564 .get(1).getLongName());
565 assertEquals("cluId2-shortName", createdClu.getAlternateIdentifiers()
566 .get(1).getShortName());
567 assertEquals("cluId2-state", createdClu.getAlternateIdentifiers()
568 .get(1).getState());
569 assertEquals("cluId2-type", createdClu.getAlternateIdentifiers().get(1)
570 .getType());
571 assertEquals("cluId2-variation", createdClu.getAlternateIdentifiers()
572 .get(1).getVariation());
573 assertEquals("cluId2-suffixcode", createdClu.getAlternateIdentifiers()
574 .get(1).getSuffixCode());
575 assertEquals("cluId2-orgid", createdClu.getAlternateIdentifiers()
576 .get(1).getOrgId());
577 assertEquals("AltIdentValue", createdClu.getAlternateIdentifiers().get(1).getAttributes().get("AltIdentKey"));
578
579 assertEquals("cluAttrValue1", createdClu.getAttributes().get(
580 "cluAttrKey1"));
581 assertEquals("cluAttrValue2", createdClu.getAttributes().get(
582 "cluAttrKey2"));
583
584 assertTrue(createdClu.isCanCreateLui());
585
586 assertEquals(545, createdClu.getDefaultEnrollmentEstimate());
587 assertEquals(999, createdClu.getDefaultMaximumEnrollment());
588
589 assertEquals("<p>DESC FORMATTED</p>", createdClu.getDescr()
590 .getFormatted());
591 assertEquals("DESC PLAIN", createdClu.getDescr().getPlain());
592
593 assertEquals(DF.parse("20100203"), createdClu.getEffectiveDate());
594 assertEquals(DF.parse("21001231"), createdClu.getExpirationDate());
595
596 assertTrue(createdClu.isEnrollable());
597
598 assertEquals("FeeAttrValue1", createdClu.getFeeInfo().getAttributes()
599 .get("FeeAttrKey1"));
600 assertEquals("FeeAttrValue2", createdClu.getFeeInfo().getAttributes()
601 .get("FeeAttrKey2"));
602
603 assertEquals("Clu Fee", createdClu.getFeeInfo().getDescr().getPlain());
604 assertEquals(2, createdClu.getFeeInfo().getCluFeeRecords().size());
605 assertEquals("FEE-TYPE-X", createdClu.getFeeInfo().getCluFeeRecords().get(0).getFeeType());
606 assertEquals("RATE-TYPE-X", createdClu.getFeeInfo().getCluFeeRecords().get(0).getRateType());
607 assertEquals("Clu Fee Record", createdClu.getFeeInfo().getCluFeeRecords().get(0).getDescr().getPlain());
608 assertEquals(3, createdClu.getFeeInfo().getCluFeeRecords().get(0).getFeeAmounts().size());
609 assertEquals(Integer.valueOf(200), createdClu.getFeeInfo().getCluFeeRecords().get(0).getFeeAmounts().get(0).getCurrencyQuantity());
610 assertEquals(0, createdClu.getFeeInfo().getCluFeeRecords().get(1).getFeeAmounts().size());
611
612 assertEquals(2, createdClu.getFeeInfo().getCluFeeRecords().get(0).getAffiliatedOrgs().size());
613 assertEquals(35l, (long)createdClu.getFeeInfo().getCluFeeRecords().get(0).getAffiliatedOrgs().get(0).getPercentage());
614
615 assertTrue(createdClu.isHasEarlyDropDeadline());
616 assertTrue(createdClu.isHazardousForDisabledStudents());
617
618 assertEquals("EXT-orgId-1", createdClu.getPrimaryInstructor()
619 .getOrgId());
620 assertEquals("EXT-personId-1", createdClu.getPrimaryInstructor()
621 .getPersonId());
622 assertEquals("PrimaryInstAttrValue1", createdClu.getPrimaryInstructor()
623 .getAttributes().get("PrimaryInstAttrKey1"));
624 assertEquals("PrimaryInstAttrValue2", createdClu.getPrimaryInstructor()
625 .getAttributes().get("PrimaryInstAttrKey2"));
626
627 assertEquals("EXT-orgId-2", createdClu.getInstructors().get(0)
628 .getOrgId());
629 assertEquals("EXT-personId-2", createdClu.getInstructors().get(0)
630 .getPersonId());
631 assertEquals("Inst1AttrValue1", createdClu.getInstructors().get(0)
632 .getAttributes().get("Inst1AttrKey1"));
633 assertEquals("Inst1AttrValue2", createdClu.getInstructors().get(0)
634 .getAttributes().get("Inst1AttrKey2"));
635
636 assertEquals("EXT-orgId-3", createdClu.getInstructors().get(1)
637 .getOrgId());
638 assertEquals("EXT-personId-3", createdClu.getInstructors().get(1)
639 .getPersonId());
640 assertEquals("Inst2AttrValue1", createdClu.getInstructors().get(1)
641 .getAttributes().get("Inst2AttrKey1"));
642 assertEquals("Inst2AttrValue2", createdClu.getInstructors().get(1)
643 .getAttributes().get("Inst2AttrKey2"));
644
645 assertEquals("luCode1.key", createdClu.getLuCodes().get(0).getId());
646 assertEquals("luCode1-desc", createdClu.getLuCodes().get(0).getDescr());
647 assertEquals("luCode1-value", createdClu.getLuCodes().get(0).getValue());
648 assertEquals("luCode1AttrValue1", createdClu.getLuCodes().get(0)
649 .getAttributes().get("luCode1AttrKey1"));
650 assertEquals("luCode1AttrValue2", createdClu.getLuCodes().get(0)
651 .getAttributes().get("luCode1AttrKey2"));
652 assertNotNull(createdClu.getLuCodes().get(0).getMetaInfo());
653 assertNotNull(createdClu.getLuCodes().get(0).getMetaInfo()
654 .getVersionInd());
655 assertNotNull(createdClu.getLuCodes().get(0).getMetaInfo()
656 .getCreateTime());
657
658 assertEquals("luCode2.key", createdClu.getLuCodes().get(1).getId());
659 assertEquals("luCode2-desc", createdClu.getLuCodes().get(1).getDescr());
660 assertEquals("luCode2-value", createdClu.getLuCodes().get(1).getValue());
661 assertEquals("luCode2AttrValue1", createdClu.getLuCodes().get(1)
662 .getAttributes().get("luCode2AttrKey1"));
663 assertEquals("luCode2AttrValue2", createdClu.getLuCodes().get(1)
664 .getAttributes().get("luCode2AttrKey2"));
665 assertNotNull(createdClu.getLuCodes().get(1).getMetaInfo());
666 assertNotNull(createdClu.getLuCodes().get(1).getMetaInfo()
667 .getVersionInd());
668 assertNotNull(createdClu.getLuCodes().get(1).getMetaInfo()
669 .getCreateTime());
670
671
672 assertEquals("nextReviewPeriod", createdClu.getNextReviewPeriod());
673
674 assertEquals("offeredAtpType1", createdClu.getOfferedAtpTypes().get(0));
675 assertEquals("offeredAtpType2", createdClu.getOfferedAtpTypes().get(1));
676
677
678 assertEquals("http://student.kuali.org/clus", createdClu
679 .getReferenceURL());
680
681 assertEquals("Clu-state", createdClu.getState());
682
683 assertEquals("EXT-stdDuration-Id1", createdClu.getStdDuration()
684 .getAtpDurationTypeKey());
685 assertEquals(Integer.valueOf(7867), createdClu.getStdDuration()
686 .getTimeQuantity());
687
688 assertEquals("luType.shell.course", createdClu.getType());
689
690 assertNotNull(createdClu.getMetaInfo());
691 assertNotNull(createdClu.getMetaInfo().getVersionInd());
692 assertNotNull(createdClu.getMetaInfo().getCreateTime());
693
694 assertNotNull(createdClu.getId());
695
696 checkCampusLocationCreate(createdClu);
697
698 checkIntensityCreate(createdClu);
699
700 checkAccreditationListCreate(createdClu);
701
702 checkAdminOrgsCreate(createdClu);
703
704
705 createdClu.getAccountingInfo().getAttributes().put(
706 "AccountingAttrKey1", "AccountingAttrValue1");
707 createdClu.getAccountingInfo().getAttributes().remove(
708 "AccountingAttrKey2");
709 createdClu.getAccountingInfo().getAttributes().put(
710 "AccountingAttrKey3", "AccountingAttrValue3");
711
712 createdClu.getOfficialIdentifier().setCode("UPoffId-code");
713 createdClu.getOfficialIdentifier().setDivision("UPoffId-division");
714 createdClu.getOfficialIdentifier().setLevel("UPoffId-level");
715 createdClu.getOfficialIdentifier().setSuffixCode("UPoffId-suffixcode");
716 createdClu.getOfficialIdentifier().setLongName("UPoffId-longName");
717 createdClu.getOfficialIdentifier().setShortName("UPoffId-shortName");
718 createdClu.getOfficialIdentifier().setState("UPoffId-state");
719 createdClu.getOfficialIdentifier().setType("UPoffId-type");
720 createdClu.getOfficialIdentifier().setVariation("UPoffId-variation");
721 createdClu.getOfficialIdentifier().getAttributes().put("OfficialIdentKeyUptd", "OfficialIdentValueUptd");
722
723
724 createdClu.getAlternateIdentifiers().get(0).setCode("UPcluId1-code");
725 createdClu.getAlternateIdentifiers().get(0).setDivision(
726 "UPcluId1-division");
727 createdClu.getAlternateIdentifiers().get(0).setLevel("UPcluId1-level");
728 createdClu.getAlternateIdentifiers().get(0).setSuffixCode(
729 "UPcluId1-suffixcode");
730 createdClu.getAlternateIdentifiers().get(0).setLongName(
731 "UPcluId1-longName");
732 createdClu.getAlternateIdentifiers().get(0).setShortName(
733 "UPcluId1-shortName");
734 createdClu.getAlternateIdentifiers().get(0).setState("UPcluId1-state");
735 createdClu.getAlternateIdentifiers().get(0).setType("UPcluId1-type");
736 createdClu.getAlternateIdentifiers().get(0).setVariation(
737 "UPcluId1-variation");
738 createdClu.getAlternateIdentifiers().get(0).getAttributes().put("AltIdentKeyUptd", "AltIdentValueUptd");
739
740 createdClu.getAlternateIdentifiers().remove(1);
741
742 CluIdentifierInfo cluId3 = new CluIdentifierInfo();
743 cluId3.setCode("cluId3-code");
744 cluId3.setDivision("cluId3-division");
745 cluId3.setSuffixCode("cluId3-suffixcode");
746 cluId3.setLevel("cluId3-level");
747 cluId3.setLongName("cluId3-longName");
748 cluId3.setShortName("cluId3-shortName");
749 cluId3.setState("cluId3-state");
750 cluId3.setType("cluId3-type");
751 cluId3.setVariation("cluId3-variation");
752
753
754 createdClu.getAlternateIdentifiers().add(cluId3);
755
756 createdClu.getAttributes().put("cluAttrKey1", "cluAttrValue1");
757 createdClu.getAttributes().remove("cluAttrKey2");
758 createdClu.getAttributes().put("cluAttrKey3", "cluAttrValue3");
759
760 createdClu.setCanCreateLui(false);
761
762 createdClu.setDefaultEnrollmentEstimate(9545);
763 createdClu.setDefaultMaximumEnrollment(9999);
764
765 createdClu.getDescr().setFormatted("UP<p>DESC FORMATTED</p>");
766 createdClu.getDescr().setPlain("UPDESC PLAIN");
767
768 createdClu.setEffectiveDate(DF.parse("20190203"));
769 createdClu.setExpirationDate(DF.parse("21091231"));
770
771 createdClu.setEnrollable(false);
772
773 createdClu.getFeeInfo().getAttributes().put("FeeAttrKey1",
774 "FeeAttrValue1");
775 createdClu.getFeeInfo().getAttributes().remove("FeeAttrKey2");
776 createdClu.getFeeInfo().getAttributes().put("FeeAttrKey3",
777 "FeeAttrValue3");
778
779 createdClu.getFeeInfo().getCluFeeRecords().get(0).getAffiliatedOrgs().remove(0);
780 createdClu.getFeeInfo().getCluFeeRecords().get(1).setFeeType("FEE-TYPE-Z");
781
782 createdClu.setHasEarlyDropDeadline(false);
783
784 createdClu.setHazardousForDisabledStudents(false);
785
786 createdClu.getPrimaryInstructor().setOrgId("UPEXT-orgId-1");
787 createdClu.getPrimaryInstructor().setPersonId("UPEXT-personId-1");
788 createdClu.getPrimaryInstructor().getAttributes().put(
789 "PrimaryInstAttrKey1", "PrimaryInstAttrValue1");
790 createdClu.getPrimaryInstructor().getAttributes().remove(
791 "PrimaryInstAttrKey2");
792 createdClu.getPrimaryInstructor().getAttributes().put(
793 "PrimaryInstAttrKey3", "PrimaryInstAttrValue3");
794
795 createdClu.getInstructors().get(0).setOrgId("UPEXT-orgId-2");
796 createdClu.getInstructors().get(0).setPersonId("UPEXT-personId-2");
797 createdClu.getInstructors().get(0).getAttributes().put("Inst1AttrKey1",
798 "Inst1AttrValue1");
799 createdClu.getInstructors().get(0).getAttributes().remove(
800 "Inst1AttrKey2");
801 createdClu.getInstructors().get(0).getAttributes().put("Inst1AttrKey3",
802 "Inst1AttrValue3");
803
804 createdClu.getInstructors().remove(1);
805
806 CluInstructorInfo instructor3 = new CluInstructorInfo();
807 instructor3.setOrgId("EXT-orgId-3");
808 instructor3.setPersonId("EXT-personId-3");
809 instructor3.getAttributes().put("Inst3AttrKey1", "Inst3AttrValue1");
810 instructor3.getAttributes().put("Inst3AttrKey2", "Inst3AttrValue2");
811 createdClu.getInstructors().add(instructor3);
812
813 createdClu.getLuCodes().get(0).setDescr("UPluCode1-desc");
814 createdClu.getLuCodes().get(0).setValue("UPluCode1-value");
815 createdClu.getLuCodes().get(0).getAttributes().put("luCode1AttrKey1",
816 "luCode1AttrValue1");
817 createdClu.getLuCodes().get(0).getAttributes()
818 .remove("luCode1AttrKey2");
819 createdClu.getLuCodes().get(0).getAttributes().put("luCode1AttrKey3",
820 "luCode1AttrValue3");
821 createdClu.getLuCodes().get(0).setType("updatedType");
822
823 createdClu.getLuCodes().remove(1);
824
825 LuCodeInfo luCode3 = new LuCodeInfo();
826 luCode3.setId("luCode3.key");
827 luCode3.setDescr("luCode3-desc");
828 luCode3.setValue("luCode3-value");
829 luCode3.getAttributes().put("luCode3AttrKey1", "luCode3AttrValue1");
830 luCode3.getAttributes().put("luCode3AttrKey2", "luCode3AttrValue2");
831 luCode3.setType("updatedType");
832 createdClu.getLuCodes().add(luCode3);
833
834
835 createdClu.setNextReviewPeriod("UPnextReviewPeriod");
836
837 createdClu.getOfferedAtpTypes().remove(1);
838 createdClu.getOfferedAtpTypes().add("offeredAtpType3");
839
840
841 CluInstructorInfo pubInstructor3 = new CluInstructorInfo();
842 pubInstructor3.setOrgId("EXT-orgId-3");
843 pubInstructor3.setPersonId("EXT-personId-3");
844 pubInstructor3.getAttributes().put("PubInst3AttrKey1",
845 "PubInst3AttrValue1");
846 pubInstructor3.getAttributes().put("PubInst3AttrKey2",
847 "PubInst3AttrValue2");
848
849 createdClu.setReferenceURL("UPhttp://student.kuali.org/clus");
850
851 createdClu.setState("UPClu-state");
852
853 createdClu.getStdDuration().setAtpDurationTypeKey(
854 "UPEXT-stdDuration-Id1");
855 createdClu.getStdDuration().setTimeQuantity(new Integer(97867));
856
857 createdClu.setType("luType.shell.program");
858
859 updateAdminOrgs(createdClu);
860
861 updateAccreditationList(createdClu);
862
863 updateIntensity(createdClu);
864
865 updateCampusLocationList(createdClu);
866
867
868 CluInfo updatedClu = client.updateClu(createdClu.getId(), createdClu);
869
870
871 assertNotNull(updatedClu);
872
873 assertEquals("AccountingAttrValue1", updatedClu.getAccountingInfo()
874 .getAttributes().get("AccountingAttrKey1"));
875 assertEquals("AccountingAttrValue3", updatedClu.getAccountingInfo()
876 .getAttributes().get("AccountingAttrKey3"));
877 assertEquals(2, updatedClu.getAccountingInfo().getAttributes().size());
878
879 assertEquals("UPoffId-code", updatedClu
880 .getOfficialIdentifier().getCode());
881 assertEquals("UPoffId-division", updatedClu.getOfficialIdentifier()
882 .getDivision());
883 assertEquals("UPoffId-level", updatedClu.getOfficialIdentifier()
884 .getLevel());
885 assertEquals("UPoffId-suffixcode", updatedClu.getOfficialIdentifier()
886 .getSuffixCode());
887 assertEquals("UPoffId-longName", updatedClu.getOfficialIdentifier()
888 .getLongName());
889 assertEquals("UPoffId-shortName", updatedClu.getOfficialIdentifier()
890 .getShortName());
891 assertEquals("UPoffId-state", updatedClu.getOfficialIdentifier()
892 .getState());
893 assertEquals("UPoffId-type", updatedClu.getOfficialIdentifier()
894 .getType());
895 assertEquals("UPoffId-variation", updatedClu.getOfficialIdentifier()
896 .getVariation());
897 assertEquals(2, updatedClu.getOfficialIdentifier().getAttributes().size());
898 assertEquals("OfficialIdentValueUptd", updatedClu.getOfficialIdentifier().getAttributes().get("OfficialIdentKeyUptd"));
899
900
901 assertEquals("UPcluId1-code", updatedClu
902 .getAlternateIdentifiers().get(0).getCode());
903 assertEquals("UPcluId1-division", updatedClu.getAlternateIdentifiers()
904 .get(0).getDivision());
905 assertEquals("UPcluId1-level", updatedClu.getAlternateIdentifiers()
906 .get(0).getLevel());
907 assertEquals("UPcluId1-suffixcode", updatedClu
908 .getAlternateIdentifiers().get(0).getSuffixCode());
909 assertEquals("UPcluId1-longName", updatedClu.getAlternateIdentifiers()
910 .get(0).getLongName());
911 assertEquals("UPcluId1-shortName", updatedClu.getAlternateIdentifiers()
912 .get(0).getShortName());
913 assertEquals("UPcluId1-state", updatedClu.getAlternateIdentifiers()
914 .get(0).getState());
915 assertEquals("UPcluId1-type", updatedClu.getAlternateIdentifiers().get(
916 0).getType());
917 assertEquals("UPcluId1-variation", updatedClu.getAlternateIdentifiers()
918 .get(0).getVariation());
919 assertEquals(2, updatedClu.getAlternateIdentifiers().get(0).getAttributes().size());
920 assertEquals("AltIdentValueUptd", createdClu.getAlternateIdentifiers().get(0).getAttributes().get("AltIdentKeyUptd"));
921
922 assertEquals("cluId3-code", updatedClu
923 .getAlternateIdentifiers().get(1).getCode());
924 assertEquals("cluId3-division", updatedClu.getAlternateIdentifiers()
925 .get(1).getDivision());
926 assertEquals("cluId3-level", updatedClu.getAlternateIdentifiers()
927 .get(1).getLevel());
928 assertEquals("cluId3-suffixcode", updatedClu.getAlternateIdentifiers()
929 .get(1).getSuffixCode());
930 assertEquals("cluId3-longName", updatedClu.getAlternateIdentifiers()
931 .get(1).getLongName());
932 assertEquals("cluId3-shortName", updatedClu.getAlternateIdentifiers()
933 .get(1).getShortName());
934 assertEquals("cluId3-state", updatedClu.getAlternateIdentifiers()
935 .get(1).getState());
936 assertEquals("cluId3-type", updatedClu.getAlternateIdentifiers().get(1)
937 .getType());
938 assertEquals("cluId3-variation", updatedClu.getAlternateIdentifiers()
939 .get(1).getVariation());
940
941 assertEquals(2, updatedClu.getAlternateIdentifiers().size());
942
943 assertEquals("cluAttrValue1", updatedClu.getAttributes().get(
944 "cluAttrKey1"));
945 assertEquals("cluAttrValue3", updatedClu.getAttributes().get(
946 "cluAttrKey3"));
947 assertEquals(2, updatedClu.getAttributes().size());
948
949 assertFalse(updatedClu.isCanCreateLui());
950
951 assertEquals(9545, updatedClu.getDefaultEnrollmentEstimate());
952 assertEquals(9999, updatedClu.getDefaultMaximumEnrollment());
953
954 assertEquals("UP<p>DESC FORMATTED</p>", updatedClu.getDescr()
955 .getFormatted());
956 assertEquals("UPDESC PLAIN", updatedClu.getDescr().getPlain());
957
958 assertEquals(DF.parse("20190203"), updatedClu.getEffectiveDate());
959 assertEquals(DF.parse("21091231"), updatedClu.getExpirationDate());
960
961 assertFalse(updatedClu.isEnrollable());
962
963 assertEquals("FeeAttrValue1", updatedClu.getFeeInfo().getAttributes()
964 .get("FeeAttrKey1"));
965 assertEquals("FeeAttrValue3", updatedClu.getFeeInfo().getAttributes()
966 .get("FeeAttrKey3"));
967 assertEquals(2, updatedClu.getFeeInfo().getAttributes().size());
968
969 assertEquals(2, createdClu.getFeeInfo().getCluFeeRecords().size());
970 assertEquals("FEE-TYPE-Z", createdClu.getFeeInfo().getCluFeeRecords().get(1).getFeeType());
971
972 assertEquals(1, createdClu.getFeeInfo().getCluFeeRecords().get(0).getAffiliatedOrgs().size());
973 assertEquals(65l, (long)createdClu.getFeeInfo().getCluFeeRecords().get(0).getAffiliatedOrgs().get(0).getPercentage());
974
975 assertFalse(updatedClu.isHasEarlyDropDeadline());
976 assertFalse(updatedClu.isHazardousForDisabledStudents());
977
978 assertEquals("UPEXT-orgId-1", updatedClu.getPrimaryInstructor()
979 .getOrgId());
980 assertEquals("UPEXT-personId-1", updatedClu.getPrimaryInstructor()
981 .getPersonId());
982 assertEquals("PrimaryInstAttrValue1", updatedClu.getPrimaryInstructor()
983 .getAttributes().get("PrimaryInstAttrKey1"));
984 assertEquals("PrimaryInstAttrValue3", updatedClu.getPrimaryInstructor()
985 .getAttributes().get("PrimaryInstAttrKey3"));
986 assertEquals(2, updatedClu.getPrimaryInstructor().getAttributes()
987 .size());
988
989 assertEquals(2, updatedClu.getInstructors().size());
990
991 assertEquals("UPEXT-orgId-2", updatedClu.getInstructors().get(0)
992 .getOrgId());
993 assertEquals("UPEXT-personId-2", updatedClu.getInstructors().get(0)
994 .getPersonId());
995 assertEquals("Inst1AttrValue1", updatedClu.getInstructors().get(0)
996 .getAttributes().get("Inst1AttrKey1"));
997 assertEquals("Inst1AttrValue3", updatedClu.getInstructors().get(0)
998 .getAttributes().get("Inst1AttrKey3"));
999 assertEquals(2, updatedClu.getInstructors().get(0).getAttributes()
1000 .size());
1001
1002 assertEquals("EXT-orgId-3", updatedClu.getInstructors().get(1)
1003 .getOrgId());
1004 assertEquals("EXT-personId-3", updatedClu.getInstructors().get(1)
1005 .getPersonId());
1006 assertEquals("Inst3AttrValue1", updatedClu.getInstructors().get(1)
1007 .getAttributes().get("Inst3AttrKey1"));
1008 assertEquals("Inst3AttrValue2", updatedClu.getInstructors().get(1)
1009 .getAttributes().get("Inst3AttrKey2"));
1010 assertEquals(2, updatedClu.getInstructors().get(1).getAttributes()
1011 .size());
1012
1013 assertEquals(2, updatedClu.getLuCodes().size());
1014
1015 assertEquals("luCode1.key", updatedClu.getLuCodes().get(0).getId());
1016 assertEquals("UPluCode1-desc", updatedClu.getLuCodes().get(0).getDescr());
1017 assertEquals("UPluCode1-value", updatedClu.getLuCodes().get(0)
1018 .getValue());
1019 assertEquals("luCode1AttrValue1", updatedClu.getLuCodes().get(0)
1020 .getAttributes().get("luCode1AttrKey1"));
1021 assertEquals("luCode1AttrValue3", updatedClu.getLuCodes().get(0)
1022 .getAttributes().get("luCode1AttrKey3"));
1023 assertEquals(2, updatedClu.getLuCodes().get(0).getAttributes().size());
1024 assertNotNull(updatedClu.getLuCodes().get(0).getMetaInfo());
1025 assertNotNull(updatedClu.getLuCodes().get(0).getMetaInfo()
1026 .getVersionInd());
1027 assertNotNull(updatedClu.getLuCodes().get(0).getMetaInfo()
1028 .getCreateTime());
1029 assertNotNull(updatedClu.getLuCodes().get(0).getMetaInfo()
1030 .getUpdateTime());
1031
1032 assertEquals("luCode3.key", updatedClu.getLuCodes().get(1).getId());
1033 assertEquals("luCode3-desc", updatedClu.getLuCodes().get(1).getDescr());
1034 assertEquals("luCode3-value", updatedClu.getLuCodes().get(1).getValue());
1035 assertEquals("luCode3AttrValue1", updatedClu.getLuCodes().get(1)
1036 .getAttributes().get("luCode3AttrKey1"));
1037 assertEquals("luCode3AttrValue2", updatedClu.getLuCodes().get(1)
1038 .getAttributes().get("luCode3AttrKey2"));
1039 assertNotNull(updatedClu.getLuCodes().get(1).getMetaInfo());
1040 assertNotNull(updatedClu.getLuCodes().get(1).getMetaInfo()
1041 .getVersionInd());
1042 assertNotNull(updatedClu.getLuCodes().get(1).getMetaInfo()
1043 .getCreateTime());
1044 assertNotNull(updatedClu.getLuCodes().get(1).getMetaInfo()
1045 .getUpdateTime());
1046
1047 assertEquals("UPnextReviewPeriod", updatedClu.getNextReviewPeriod());
1048
1049 assertEquals("offeredAtpType1", updatedClu.getOfferedAtpTypes().get(0));
1050 assertEquals("offeredAtpType3", updatedClu.getOfferedAtpTypes().get(1));
1051 assertEquals(2, updatedClu.getOfferedAtpTypes().size());
1052
1053
1054 assertEquals("UPhttp://student.kuali.org/clus", updatedClu
1055 .getReferenceURL());
1056
1057 assertEquals("UPClu-state", updatedClu.getState());
1058
1059 assertEquals("UPEXT-stdDuration-Id1", updatedClu.getStdDuration()
1060 .getAtpDurationTypeKey());
1061 assertEquals(Integer.valueOf(97867), updatedClu.getStdDuration()
1062 .getTimeQuantity());
1063
1064 assertEquals("luType.shell.program", updatedClu.getType());
1065
1066 assertEquals(false,updatedClu.isEnrollable());
1067 assertEquals(false,updatedClu.isHazardousForDisabledStudents());
1068
1069 assertNotNull(updatedClu.getMetaInfo());
1070 assertNotNull(updatedClu.getMetaInfo().getVersionInd());
1071 assertNotNull(updatedClu.getMetaInfo().getCreateTime());
1072 assertNotNull(updatedClu.getMetaInfo().getUpdateTime());
1073
1074 assertEquals(createdClu.getId(), updatedClu.getId());
1075
1076 checkAdminOrgUpdate(updatedClu);
1077
1078 checkAccreditationListUpdate(updatedClu);
1079
1080 checkCampusLocationUpdate(updatedClu);
1081
1082 checkIntensityUpdate(updatedClu);
1083
1084
1085 try {
1086 updatedClu = client.updateClu(createdClu.getId(), createdClu);
1087 fail("Should have thrown VersionMismatchException");
1088 } catch (VersionMismatchException e) {
1089
1090 }
1091
1092
1093 try {
1094 client.getClu(createdClu.getId());
1095 } catch (DoesNotExistException e) {
1096 fail("Should not have thrown DoesNotExistException");
1097 }
1098
1099 StatusInfo status = client.deleteClu(createdClu.getId());
1100 assertTrue(status.getSuccess());
1101
1102 try {
1103 client.getClu(createdClu.getId());
1104 fail("Should have thrown DoesNotExistException");
1105 } catch (DoesNotExistException e) {
1106
1107 }
1108
1109 }
1110
1111 @Test
1112 public void testCluCluRelationCrud() throws Exception {
1113
1114 final CluCluRelationInfo cluCluRelationInfo = new CluCluRelationInfo();
1115
1116 final Date effectiveDate = DF.parse("20080101"), expirationDate = DF
1117 .parse("20100101");
1118 cluCluRelationInfo.setEffectiveDate(effectiveDate);
1119 cluCluRelationInfo.setExpirationDate(expirationDate);
1120 cluCluRelationInfo.setIsCluRelationRequired(true);
1121 cluCluRelationInfo.setState("hello");
1122 cluCluRelationInfo.getAttributes().put("clucluAttrKey1",
1123 "clucluAttrValue1");
1124 cluCluRelationInfo.getAttributes().put("clucluAttrKey2",
1125 "clucluAttrValue2");
1126 cluCluRelationInfo.getAttributes().put("clucluAttrKey3",
1127 "clucluAttrValue3");
1128
1129 CluCluRelationInfo created = client.createCluCluRelation("CLU-1",
1130 "CLU-2", "luLuType.type1", cluCluRelationInfo);
1131
1132 assertEquals(effectiveDate, created.getEffectiveDate());
1133 assertEquals(expirationDate, created.getExpirationDate());
1134 assertEquals(true, created.getIsCluRelationRequired());
1135 assertEquals("hello", created.getState());
1136 assertEquals("CLU-1", created.getCluId());
1137 assertEquals("CLU-2", created.getRelatedCluId());
1138 assertEquals("luLuType.type1", created.getType());
1139 assertEquals("clucluAttrValue1", created.getAttributes().get(
1140 "clucluAttrKey1"));
1141 assertEquals("clucluAttrValue2", created.getAttributes().get(
1142 "clucluAttrKey2"));
1143 assertEquals("clucluAttrValue3", created.getAttributes().get(
1144 "clucluAttrKey3"));
1145 assertNotNull(created.getId());
1146 assertNotNull(created.getMetaInfo().getCreateTime());
1147 assertNotNull(created.getMetaInfo().getVersionInd());
1148
1149 created.getAttributes().remove("clucluAttrKey2");
1150 created.getAttributes().put("clucluAttrKey3", "clucluAttrValue3-A");
1151 created.getAttributes().put("clucluAttrKey4", "clucluAttrValue4");
1152 created.setCluId("CLU-2");
1153 created.setEffectiveDate(expirationDate);
1154 created.setExpirationDate(effectiveDate);
1155 created.setIsCluRelationRequired(false);
1156 created.setRelatedCluId("CLU-3");
1157 created.setState("updated hello");
1158 created.setType("luLuType.type2");
1159
1160 CluCluRelationInfo updated = client.updateCluCluRelation(created
1161 .getId(), created);
1162
1163 assertEquals(expirationDate, updated.getEffectiveDate());
1164 assertEquals(effectiveDate, updated.getExpirationDate());
1165 assertEquals(false, updated.getIsCluRelationRequired());
1166 assertEquals("updated hello", updated.getState());
1167 assertEquals("CLU-2", updated.getCluId());
1168 assertEquals("CLU-3", updated.getRelatedCluId());
1169 assertEquals("luLuType.type2", updated.getType());
1170 assertEquals("clucluAttrValue1", updated.getAttributes().get(
1171 "clucluAttrKey1"));
1172 assertNull(updated.getAttributes().get("clucluAttrKey2"));
1173 assertEquals("clucluAttrValue3-A", updated.getAttributes().get(
1174 "clucluAttrKey3"));
1175 assertEquals("clucluAttrValue4", updated.getAttributes().get(
1176 "clucluAttrKey4"));
1177 assertNotNull(created.getId());
1178 assertNotNull(created.getMetaInfo().getCreateTime());
1179 assertNotNull(created.getMetaInfo().getVersionInd());
1180
1181
1182 try {
1183 client.getCluCluRelation(created.getId());
1184 } catch (DoesNotExistException e) {
1185 fail("Should not have thrown DoesNotExistException");
1186 }
1187
1188 StatusInfo status = client.deleteCluCluRelation(created.getId());
1189 assertTrue(status.getSuccess());
1190
1191 try {
1192 client.getCluCluRelation(created.getId());
1193 fail("Should have thrown DoesNotExistException");
1194 } catch (DoesNotExistException e) {
1195
1196 }
1197
1198 List<String> relatedCluIdsByCluId = client.getRelatedCluIdsByCluId(
1199 "CLU-1", "luLuType.type1");
1200
1201 assertEquals(2, relatedCluIdsByCluId.size());
1202 assertTrue(relatedCluIdsByCluId.contains("CLU-2"));
1203 assertTrue(relatedCluIdsByCluId.contains("CLU-3"));
1204
1205 List<CluInfo> relatedClusByCluId = client.getRelatedClusByCluId(
1206 "CLU-1", "luLuType.type1");
1207 assertEquals(2, relatedClusByCluId.size());
1208 }
1209
1210 @Test
1211 public void testLuiLuiRelationCrud() throws Exception {
1212
1213 LuiLuiRelationInfo luiLuiRelationInfo = new LuiLuiRelationInfo();
1214
1215 luiLuiRelationInfo.setEffectiveDate(DF.parse("20080101"));
1216 luiLuiRelationInfo.setExpirationDate(DF.parse("20100101"));
1217 luiLuiRelationInfo.setState("hello");
1218 luiLuiRelationInfo.setType("goodbye");
1219 luiLuiRelationInfo.getAttributes().put("luiluiAttrKey1",
1220 "luiluiAttrValue1");
1221 luiLuiRelationInfo.getAttributes().put("luiluiAttrKey2",
1222 "luiluiAttrValue2");
1223
1224 LuiLuiRelationInfo created = client.createLuiLuiRelation("LUI-1",
1225 "LUI-2", "luLuType.type1", luiLuiRelationInfo);
1226
1227 assertEquals(DF.parse("20080101"), created.getEffectiveDate());
1228 assertEquals(DF.parse("20100101"), created.getExpirationDate());
1229 assertEquals("hello", created.getState());
1230 assertEquals("luLuType.type1", created.getType());
1231 assertEquals("LUI-1", created.getLuiId());
1232 assertEquals("LUI-2", created.getRelatedLuiId());
1233 assertEquals("luiluiAttrValue1", created.getAttributes().get(
1234 "luiluiAttrKey1"));
1235 assertEquals("luiluiAttrValue2", created.getAttributes().get(
1236 "luiluiAttrKey2"));
1237 assertNotNull(created.getId());
1238 assertNotNull(created.getMetaInfo().getCreateTime());
1239 assertNotNull(created.getMetaInfo().getVersionInd());
1240
1241 created.setEffectiveDate(DF.parse("20980101"));
1242 created.setExpirationDate(DF.parse("20190101"));
1243 created.setState("sawyer");
1244 created.setType("luLuType.type2");
1245 created.setLuiId("LUI-2");
1246 created.setRelatedLuiId("LUI-3");
1247 created.getAttributes().put("luiluiAttrKey1", "UPluiluiAttrValue1");
1248 created.getAttributes().remove("luiluiAttrKey2");
1249 created.getAttributes().put("luiluiAttrKey3", "luiluiAttrValue3");
1250
1251 LuiLuiRelationInfo updated = client.updateLuiLuiRelation(created
1252 .getId(), created);
1253
1254 assertEquals(DF.parse("20980101"), updated.getEffectiveDate());
1255 assertEquals(DF.parse("20190101"), updated.getExpirationDate());
1256 assertEquals("sawyer", updated.getState());
1257 assertEquals("luLuType.type2", updated.getType());
1258 assertEquals("LUI-2", updated.getLuiId());
1259 assertEquals("LUI-3", updated.getRelatedLuiId());
1260 assertEquals("UPluiluiAttrValue1", updated.getAttributes().get(
1261 "luiluiAttrKey1"));
1262 assertEquals("luiluiAttrValue3", updated.getAttributes().get(
1263 "luiluiAttrKey3"));
1264 assertEquals(2, updated.getAttributes().size());
1265 assertEquals(created.getId(), updated.getId());
1266 assertNotNull(updated.getMetaInfo().getUpdateTime());
1267
1268 try {
1269 updated = client.updateLuiLuiRelation(created.getId(), created);
1270 fail("Should have thrown VersionMismatchException");
1271 } catch (VersionMismatchException e) {
1272 }
1273
1274 try {
1275 client.getLuiLuiRelation(created.getId());
1276 } catch (DoesNotExistException e) {
1277 fail("Should not have thrown DoesNotExistException");
1278 }
1279
1280 StatusInfo status = client.deleteLuiLuiRelation(updated.getId());
1281
1282 assertTrue(status.getSuccess());
1283
1284 try {
1285 client.getLuiLuiRelation(created.getId());
1286 fail("Should have thrown DoesNotExistException");
1287 } catch (DoesNotExistException e) {
1288
1289 }
1290
1291
1292 List<LuiLuiRelationInfo> relations = client
1293 .getLuiLuiRelationsByLui("LUI-1");
1294 assertEquals(2, relations.size());
1295 relations = client.getLuiLuiRelationsByLui("LUI-2");
1296 assertEquals(1, relations.size());
1297 relations = client.getLuiLuiRelationsByLui("LUI-3");
1298 assertTrue(relations == null || relations.size() == 0);
1299
1300 List<String> relatedLuiIdsByLuiId = client.getRelatedLuiIdsByLuiId(
1301 "LUI-1", "luLuType.type1");
1302 assertEquals(2, relatedLuiIdsByLuiId.size());
1303 assertTrue(relatedLuiIdsByLuiId.contains("LUI-2"));
1304 assertTrue(relatedLuiIdsByLuiId.contains("LUI-3"));
1305
1306 List<LuiInfo> relatedLuisByLuiId = client.getRelatedLuisByLuiId(
1307 "LUI-1", "luLuType.type1");
1308 assertEquals(2, relatedLuisByLuiId.size());
1309
1310 }
1311
1312 @Test
1313 public void testGetLuisByIdList() throws DoesNotExistException,
1314 InvalidParameterException, MissingParameterException,
1315 OperationFailedException {
1316 List<LuiInfo> luiInfos;
1317 try {
1318 luiInfos = client.getLuisByIdList(null);
1319 fail("LuService.getLuiByIdList() did not throw MissingParameterException for null Lui ID");
1320 } catch (MissingParameterException mpe) {
1321 } catch (Exception e) {
1322 fail("LuService.getLuiByIdList() threw unexpected "
1323 + e.getClass().getSimpleName() + " for null Lui ID");
1324 }
1325 luiInfos = client.getLuisByIdList(Arrays.asList("Not a LUI ID",
1326 "Another one that ain't"));
1327 assertTrue(luiInfos == null || luiInfos.size() == 0);
1328
1329 luiInfos = client.getLuisByIdList(Arrays.asList("LUI-1", "LUI-4"));
1330 Collections.sort(luiInfos, new Comparator<LuiInfo>() {
1331 @Override
1332 public int compare(LuiInfo o1, LuiInfo o2) {
1333 return o1.getId().compareTo(o2.getId());
1334 }
1335 });
1336 assertEquals("CLU-1", luiInfos.get(0).getCluId());
1337 assertEquals("CLU-2", luiInfos.get(1).getCluId());
1338 }
1339
1340 @Test
1341 public void testLuiCrud() throws AlreadyExistsException,
1342 DataValidationErrorException, DoesNotExistException,
1343 InvalidParameterException, MissingParameterException,
1344 OperationFailedException, PermissionDeniedException,
1345 ParseException, DependentObjectsExistException {
1346
1347 LuiInfo luiInfo;
1348
1349
1350 try {
1351 luiInfo = client.getLui("notARealLui");
1352 fail("LuService.getLui() did not throw DoesNotExistException for non-existent Lui");
1353 } catch (DoesNotExistException dnee) {
1354 } catch (Exception e) {
1355 fail("LuService.getLui() threw unexpected "
1356 + e.getClass().getSimpleName() + " for null Lui ID");
1357 }
1358 try {
1359 luiInfo = client.getLui(null);
1360 fail("LuService.getLui() did not throw MissingParameterException for null Lui ID");
1361 } catch (MissingParameterException mpe) {
1362 }
1363 luiInfo = client.getLui("LUI-1");
1364 assertEquals("CLU-1", luiInfo.getCluId());
1365
1366
1367 luiInfo = new LuiInfo();
1368
1369 luiInfo.setLuiCode("LUI Test Code");
1370 luiInfo.setMaxSeats(100);
1371 luiInfo.setState("Test Lui State");
1372 luiInfo.setEffectiveDate(DF.parse("20101203"));
1373 luiInfo.setExpirationDate(DF.parse("20801231"));
1374 luiInfo.getAttributes().put("luiAttrKey1", "luiAttrValue1");
1375 luiInfo.getAttributes().put("luiAttrKey2", "luiAttrValue2");
1376
1377 LuiInfo createdLui = client.createLui("CLU-2", "ATP-3", luiInfo);
1378
1379 assertEquals("ATP-3", createdLui.getAtpId());
1380 assertEquals("LUI Test Code", createdLui.getLuiCode());
1381 assertEquals(100L, (long) createdLui.getMaxSeats());
1382 assertEquals(DF.parse("20101203"), luiInfo.getEffectiveDate());
1383 assertEquals(DF.parse("20801231"), luiInfo.getExpirationDate());
1384 assertEquals("CLU-2", createdLui.getCluId());
1385 assertEquals(2, createdLui.getAttributes().size());
1386 assertEquals("luiAttrValue1", createdLui.getAttributes().get(
1387 "luiAttrKey1"));
1388 assertEquals("luiAttrValue2", createdLui.getAttributes().get(
1389 "luiAttrKey2"));
1390
1391
1392 createdLui.setAtpId("ATP-2");
1393 createdLui.setCluId("CLU-1");
1394 createdLui.setLuiCode("LUI Test Code Update");
1395 createdLui.setMaxSeats(75);
1396 createdLui.setState("Test Lui State Update");
1397 createdLui.setEffectiveDate(DF.parse("20111203"));
1398 createdLui.setExpirationDate(DF.parse("20811231"));
1399 createdLui.getAttributes().put("luiAttrKey1", "luiAttrValue1Updated");
1400 createdLui.getAttributes().put("luiAttrKey2", "luiAttrValue2Updated");
1401
1402 LuiInfo updatedLui = null;
1403 try {
1404 updatedLui = client.updateLui(createdLui.getId(), createdLui);
1405 } catch (VersionMismatchException vme) {
1406 fail("LuService.updateLui() threw unexpected VersionMismatchException");
1407 }
1408
1409
1410 assertTrue(null != updatedLui);
1411 assertEquals("ATP-2", updatedLui.getAtpId());
1412 assertEquals("CLU-1", updatedLui.getCluId());
1413 assertEquals("LUI Test Code Update", updatedLui.getLuiCode());
1414 assertEquals(75L, (long) createdLui.getMaxSeats());
1415 assertEquals(DF.parse("20111203"), updatedLui.getEffectiveDate());
1416 assertEquals(DF.parse("20811231"), updatedLui.getExpirationDate());
1417 assertEquals(2, updatedLui.getAttributes().size());
1418 assertEquals("luiAttrValue1Updated", updatedLui.getAttributes().get(
1419 "luiAttrKey1"));
1420 assertEquals("luiAttrValue2Updated", updatedLui.getAttributes().get(
1421 "luiAttrKey2"));
1422
1423
1424 try {
1425 client.updateLui(createdLui.getId(), createdLui);
1426 fail("LuService.updateLui did not throw expected VersionMismatchException");
1427 } catch (VersionMismatchException e) {
1428 }
1429
1430
1431 client.deleteLui(createdLui.getId());
1432
1433 try {
1434 client.deleteLui(createdLui.getId());
1435 fail("LuService.deleteLui() of previously-delete Lui did not throw expected DoesNotExistException");
1436 } catch (DoesNotExistException dnee) {
1437 }
1438 }
1439
1440 @Test
1441 public void testGetLuiIdsByCluId() throws DoesNotExistException,
1442 InvalidParameterException, MissingParameterException,
1443 OperationFailedException {
1444 List<String> luiIds = null;
1445 try {
1446 luiIds = client.getLuiIdsByCluId(null);
1447 fail("LuService.getLuiIdsByCluId() did not throw MissingParameterException for null Clu ID");
1448 } catch (MissingParameterException e) {
1449 }
1450 luiIds = client.getLuiIdsByCluId("CLU-1");
1451
1452 Collections.sort(luiIds);
1453
1454 assertTrue(null != luiIds);
1455 assertEquals(3, luiIds.size());
1456
1457 assertEquals("LUI-1", luiIds.get(0));
1458 assertEquals("LUI-3", luiIds.get(2));
1459 luiIds = client.getLuiIdsByCluId("CLU-2");
1460 assertEquals(1, luiIds.size());
1461 luiIds = client.getLuiIdsByCluId("Non-existent Clu");
1462 assertTrue(null == luiIds || luiIds.size() == 0);
1463 }
1464
1465 @Test
1466 public void testGetLuiIdsInAtpByCluId() throws DoesNotExistException,
1467 InvalidParameterException, OperationFailedException,
1468 MissingParameterException {
1469 List<String> luiIds = null;
1470 try {
1471 luiIds = client.getLuiIdsInAtpByCluId(null, "ATP-1");
1472 fail("LuService.getLuiIdsInAtpByCluId() did not throw MissingParameterException for null Clu ID");
1473 } catch (MissingParameterException e) {
1474 }
1475 try {
1476 luiIds = client.getLuiIdsInAtpByCluId("CLU-1", null);
1477 fail("LuService.getLuiIdsInAtpByCluId() did not throw MissingParameterException for null AtpKey");
1478 } catch (MissingParameterException e) {
1479 }
1480 luiIds = client.getLuiIdsInAtpByCluId("CLU-1", "ATP-2");
1481 Collections.sort(luiIds);
1482 assertTrue(null != luiIds);
1483 assertEquals(2, luiIds.size());
1484 assertEquals("LUI-2", luiIds.get(0));
1485 assertEquals("LUI-3", luiIds.get(1));
1486 luiIds = client.getLuiIdsInAtpByCluId("CLU-1", "ATP-1");
1487 assertEquals(1, luiIds.size());
1488 luiIds = client.getLuiIdsInAtpByCluId("Non-existent Clu", "ATP-2");
1489 assertTrue(null == luiIds || luiIds.size() == 0);
1490 luiIds = client.getLuiIdsInAtpByCluId("CLU-2", "Non-existent ATP");
1491 assertTrue(null == luiIds || luiIds.size() == 0);
1492 }
1493
1494 @Test
1495 public void testGetLuLuRelationTypeInfo() throws OperationFailedException,
1496 DoesNotExistException, MissingParameterException {
1497 LuLuRelationTypeInfo luLuRelTypeInfo;
1498
1499 try {
1500 client.getLuLuRelationType(null);
1501 fail("LuService.getLuLuRelationTypeInfo() did not throw MissingParameterException for null LuLuRelationType key");
1502 } catch (MissingParameterException e) {
1503 }
1504 luLuRelTypeInfo = client.getLuLuRelationType("luLuType.type1");
1505 assertEquals("bob", luLuRelTypeInfo.getName());
1506 luLuRelTypeInfo = client.getLuLuRelationType("luLuType.type2");
1507 assertEquals("my desc2", luLuRelTypeInfo.getDescr());
1508 assertEquals("rev name2", luLuRelTypeInfo.getRevName());
1509 assertEquals("rev desc2", luLuRelTypeInfo.getRevDesc());
1510 try {
1511 client.getLuLuRelationType("Non-existent LuLuRelationType");
1512 fail("LuService.getLuLuRelationTypeInfo() did not throw DoesNotExistException when retrieving non-existent LuLuRelationType");
1513 } catch (DoesNotExistException dnee) {
1514 }
1515 }
1516
1517 @Test
1518 public void testGetLuLuRelationTypeInfos() throws OperationFailedException,
1519 DoesNotExistException, MissingParameterException {
1520 List<LuLuRelationTypeInfo> luLuRelTypeInfos;
1521 luLuRelTypeInfos = client.getLuLuRelationTypes();
1522 Collections.sort(luLuRelTypeInfos,
1523 new Comparator<LuLuRelationTypeInfo>() {
1524 @Override
1525 public int compare(LuLuRelationTypeInfo o1,
1526 LuLuRelationTypeInfo o2) {
1527 return o1.getId().compareTo(o2.getId());
1528 }
1529 });
1530 assertEquals(13, luLuRelTypeInfos.size());
1531 assertEquals("kuali.lu.lu.relation.type.hasCoreProgram", luLuRelTypeInfos.get(0).getId());
1532 }
1533
1534 @Test
1535 public void testUpdateLuiState() throws DataValidationErrorException,
1536 DoesNotExistException, InvalidParameterException,
1537 OperationFailedException, PermissionDeniedException,
1538 ParseException, AlreadyExistsException, MissingParameterException,
1539 DependentObjectsExistException {
1540 try {
1541 client.updateLuiState(null, "Suspended");
1542 fail("LuService.updateLuiState() did not throw MissingParameterException for null Lui ID");
1543 } catch (MissingParameterException e) {
1544 }
1545 try {
1546 client.updateLuiState("LUI-1", null);
1547 fail("LuService.updateLuiState() did not throw MissingParameterException for null state");
1548 } catch (MissingParameterException e) {
1549 }
1550
1551
1552
1553 LuiInfo luiInfo = new LuiInfo();
1554
1555 luiInfo.setLuiCode("LUI Test Code");
1556 luiInfo.setMaxSeats(100);
1557 luiInfo.setState("Approved");
1558 luiInfo.setEffectiveDate(DF.parse("20101203"));
1559 luiInfo.setExpirationDate(DF.parse("20801231"));
1560 luiInfo.getAttributes().put("luiAttrKey1", "luiAttrValue1");
1561 luiInfo.getAttributes().put("luiAttrKey2", "luiAttrValue2");
1562
1563 LuiInfo createdLui = client.createLui("CLU-2", "ATP-3", luiInfo);
1564
1565 assertEquals("Approved", createdLui.getState());
1566
1567
1568 LuiInfo updatedLui = client.updateLuiState(createdLui.getId(),
1569 "Active");
1570 assertEquals("Active", updatedLui.getState());
1571
1572
1573
1574 updatedLui = client.getLui(createdLui.getId());
1575 assertEquals("Active", updatedLui.getState());
1576
1577
1578 client.deleteLui(updatedLui.getId());
1579 }
1580
1581 @Test
1582 public void testGetLuisByRelation() throws DoesNotExistException,
1583 InvalidParameterException, MissingParameterException,
1584 OperationFailedException {
1585 List<LuiInfo> luis = client
1586 .getLuisByRelation("LUI-1", "luLuType.type1");
1587 assertTrue(luis == null || luis.size() == 0);
1588 luis = client.getLuisByRelation("LUI-2", "luLuType.type1");
1589 Collections.sort(luis, new Comparator<LuiInfo>() {
1590 @Override
1591 public int compare(LuiInfo o1, LuiInfo o2) {
1592 return o1.getId().compareTo(o2.getId());
1593 }
1594 });
1595 assertEquals(1, luis.size());
1596 assertEquals("LUI-1", luis.get(0).getId());
1597 }
1598
1599 @Test
1600 public void testGetLuiIdsByRelation() throws DoesNotExistException,
1601 InvalidParameterException, MissingParameterException,
1602 OperationFailedException {
1603 List<String> luis = client.getLuiIdsByRelation("LUI-1",
1604 "luLuType.type1");
1605 assertTrue(luis == null || luis.size() == 0);
1606 luis = client.getLuiIdsByRelation("LUI-2", "luLuType.type1");
1607 Collections.sort(luis);
1608 assertEquals(1, luis.size());
1609 assertEquals("LUI-1", luis.get(0));
1610 }
1611
1612 @Test
1613 public void testOutcomeLO() throws AlreadyExistsException,
1614 DoesNotExistException, InvalidParameterException,
1615 MissingParameterException, OperationFailedException,
1616 PermissionDeniedException, DependentObjectsExistException,
1617 ParseException, DataValidationErrorException,
1618 VersionMismatchException {
1619
1620 CluLoRelationInfo reltnInfo = new CluLoRelationInfo();
1621 reltnInfo.setCluId("CLU-1");
1622 reltnInfo.setLoId("LO-1");
1623 reltnInfo.setState("FINAL");
1624 reltnInfo.setType("kuali.lu.lo.relation.type.includes");
1625 reltnInfo.setEffectiveDate(DF.parse("20101203"));
1626 reltnInfo.setExpirationDate(DF.parse("20801231"));
1627
1628 CluLoRelationInfo crReltnInfo = client.createCluLoRelation("CLU-1",
1629 "LO-1", "kuali.lu.lo.relation.type.includes", reltnInfo);
1630
1631 assertEquals(crReltnInfo.getCluId(), "CLU-1");
1632 assertEquals(crReltnInfo.getLoId(), "LO-1");
1633 assertEquals(crReltnInfo.getState(), "FINAL");
1634 assertEquals(crReltnInfo.getType(), "kuali.lu.lo.relation.type.includes");
1635
1636 try {
1637 client.createCluLoRelation("CLU-1", "LO-1", "kuali.lu.lo.relation.type.includes", reltnInfo);
1638 fail("Should have thrown AlreadyExistsException");
1639 } catch (AlreadyExistsException e) {
1640
1641 }
1642
1643 try {
1644 reltnInfo.setCluId("MISSING CLU");
1645 client.createCluLoRelation("MISSING CLU", "LO-1", "kuali.lu.lo.relation.type.includes",
1646 reltnInfo);
1647 fail("Should have thrown DoesNotExistException");
1648 } catch (DoesNotExistException e) {
1649
1650 }
1651
1652 CluLoRelationInfo gtReltnInfo = client.getCluLoRelation(crReltnInfo
1653 .getId());
1654
1655 assertEquals(gtReltnInfo.getCluId(), "CLU-1");
1656 assertEquals(gtReltnInfo.getLoId(), "LO-1");
1657 assertEquals(gtReltnInfo.getState(), "FINAL");
1658 assertEquals(gtReltnInfo.getType(), "kuali.lu.lo.relation.type.includes");
1659
1660 CluLoRelationInfo reltnInfo1 = new CluLoRelationInfo();
1661 reltnInfo1.setCluId("CLU-1");
1662 reltnInfo1.setLoId("LO-2");
1663 reltnInfo1.setState("FINAL");
1664 reltnInfo1.setType("kuali.lu.lo.relation.type.includes");
1665 reltnInfo1.setEffectiveDate(DF.parse("20101203"));
1666 reltnInfo1.setExpirationDate(DF.parse("20801231"));
1667
1668 CluLoRelationInfo crReltnInfo1 = client.createCluLoRelation("CLU-1",
1669 "LO-2", "kuali.lu.lo.relation.type.includes", reltnInfo1);
1670
1671 List<CluLoRelationInfo> reltns = client.getCluLoRelationsByClu("CLU-1");
1672 assertEquals(2, reltns.size());
1673
1674 List<CluLoRelationInfo> reltns1 = client.getCluLoRelationsByLo("LO-1");
1675 assertEquals(1, reltns1.size());
1676 assertEquals(reltns1.get(0).getCluId(), "CLU-1");
1677
1678
1679 crReltnInfo1.setState("NEW");
1680 CluLoRelationInfo updateReltn = client.updateCluLoRelation(crReltnInfo1
1681 .getId(), crReltnInfo1);
1682 assertEquals("NEW", updateReltn.getState());
1683
1684 StatusInfo status = client.deleteCluLoRelation(crReltnInfo.getId());
1685 assertTrue(status.getSuccess());
1686
1687 status = client.deleteCluLoRelation(updateReltn.getId());
1688 assertTrue(status.getSuccess());
1689
1690 }
1691
1692 @Test
1693 public void testResultUsageType() throws DoesNotExistException,
1694 InvalidParameterException, MissingParameterException,
1695 OperationFailedException {
1696 ResultUsageTypeInfo lrType = client.getResultUsageType("lrType.finalGrade");
1697 assertEquals("Final Grade", lrType.getName());
1698 List<ResultUsageTypeInfo> lrTypes = client.getResultUsageTypes();
1699 assertEquals(2, lrTypes.size());
1700
1701 }
1702
1703 @Test
1704 public void testGetClusByRelation() throws AlreadyExistsException,
1705 DataValidationErrorException, DoesNotExistException,
1706 InvalidParameterException, MissingParameterException,
1707 OperationFailedException, PermissionDeniedException,
1708 ParseException, VersionMismatchException {
1709 List<CluInfo> clus = client
1710 .getClusByRelation("CLU-1", "luLuType.type1");
1711 assertNotNull(clus);
1712 assertEquals(2, clus.size());
1713
1714 clus = client.getClusByRelation("CLUXX-2", "luLuType.type1");
1715 assertTrue(clus == null || clus.size() == 0);
1716
1717 clus = client.getClusByRelation("CLU-2", "luLuType.type1XX");
1718 assertTrue(clus == null || clus.size() == 0);
1719
1720 try {
1721 clus = client.getClusByRelation(null, "luLuType.type1XX");
1722 assertTrue(false);
1723 } catch (MissingParameterException e) {
1724 assertTrue(true);
1725 }
1726 try {
1727 clus = client.getClusByRelation("CLU-2", null);
1728 assertTrue(false);
1729 } catch (MissingParameterException e) {
1730 assertTrue(true);
1731 }
1732
1733 List<String> ids = client.getCluIdsByRelation("CLU-2", "luLuType.type1");
1734 assertNotNull(ids);
1735 assertEquals(1, ids.size());
1736
1737 ids = client.getCluIdsByRelation("CLUXX-2", "luLuType.type1");
1738 assertTrue(null == ids || ids.size() == 0);
1739
1740 ids = client.getCluIdsByRelation("CLU-2", "luLuType.type1XX");
1741 assertTrue(null == ids || ids.size() == 0);
1742
1743 try {
1744 ids = client.getCluIdsByRelation(null, "luLuType.type1XX");
1745 assertTrue(false);
1746 } catch (MissingParameterException e) {
1747 assertTrue(true);
1748 }
1749 try {
1750 ids = client.getCluIdsByRelation("CLU-2", null);
1751 assertTrue(false);
1752 } catch (MissingParameterException e) {
1753 assertTrue(true);
1754 }
1755 }
1756
1757
1758 public void testSearchForResults() throws AlreadyExistsException,
1759 DataValidationErrorException, DoesNotExistException,
1760 InvalidParameterException, MissingParameterException,
1761 OperationFailedException, PermissionDeniedException,
1762 ParseException, VersionMismatchException {
1763 List<SearchParam> queryParamValues = new ArrayList<SearchParam>(
1764 0);
1765 SearchRequest searchRequest = new SearchRequest();
1766 searchRequest.setSearchKey("lu.search.clus");
1767 searchRequest.setParams(queryParamValues);
1768 SearchResult clus = client.search(searchRequest);
1769 Collections.sort(clus.getRows(), new Comparator<SearchResultRow>() {
1770 @Override
1771 public int compare(SearchResultRow o1, SearchResultRow o2) {
1772 return o1.getCells().get(0).getValue().compareTo(
1773 o2.getCells().get(0).getValue());
1774 }
1775 });
1776 assertNotNull(clus);
1777 assertEquals(103, clus.getRows().size());
1778 SearchResultRow result = clus.getRows().get(0);
1779 assertNotNull(result);
1780
1781 List<SearchResultCell> resultCells = result.getCells();
1782 assertNotNull(resultCells);
1783 assertEquals(2, resultCells.size());
1784
1785 SearchResultCell resultCell = resultCells.get(0);
1786 assertEquals("lu.resultColumn.cluId", resultCell.getKey());
1787 assertEquals("00000000-a389-4fd0-b349-1e649c20fd08", resultCell
1788 .getValue());
1789 resultCell = resultCells.get(1);
1790 assertEquals("lu.resultColumn.cluOfficialIdentifier.longName",
1791 resultCell.getKey());
1792 assertEquals("Advanced Applied Linear Algebra", resultCell.getValue());
1793 }
1794
1795 @Test
1796 public void testSearchCourseLevelRanges() throws MissingParameterException {
1797 List<SearchParam> queryParamValues = new ArrayList<SearchParam>();
1798 SearchParam courseLevelsParam = new SearchParam();
1799 courseLevelsParam.setKey("lu.queryParam.luOptionalCrsNoRange");
1800 courseLevelsParam.setValue("100 -200");
1801 queryParamValues.add(courseLevelsParam);
1802 SearchRequest searchRequest = new SearchRequest();
1803 searchRequest.setSearchKey("lu.search.generic");
1804 searchRequest.setParams(queryParamValues);
1805 SearchResult clus = client.search(searchRequest);
1806 Collections.sort(clus.getRows(), new Comparator<SearchResultRow>() {
1807 @Override
1808 public int compare(SearchResultRow o1, SearchResultRow o2) {
1809 return o1.getCells().get(0).getValue().compareTo(
1810 o2.getCells().get(0).getValue());
1811 }
1812 });
1813 assertNotNull(clus);
1814 LOG.warn(clus.getRows().size());
1815 }
1816
1817 @Test
1818 public void testCluValidation() throws ParseException, AlreadyExistsException,
1819 DataValidationErrorException, DoesNotExistException,
1820 InvalidParameterException, MissingParameterException,
1821 OperationFailedException, PermissionDeniedException,
1822 VersionMismatchException, DependentObjectsExistException {
1823
1824 CluInfo clu = new CluInfo();
1825
1826 CluAccountingInfo accountingInfo = new CluAccountingInfo();
1827 accountingInfo.getAttributes().put("AccountingAttrKey1",
1828 "AccountingAttrValue1");
1829 accountingInfo.getAttributes().put("AccountingAttrKey2",
1830 "AccountingAttrValue2");
1831 clu.setAccountingInfo(accountingInfo);
1832
1833 CluIdentifierInfo officialIdentifier = new CluIdentifierInfo();
1834 officialIdentifier.setType("kuali.lu.type.CreditCourse.identifier.official");
1835 officialIdentifier.setState("active");
1836 officialIdentifier.setCode("offIdcode");
1837 officialIdentifier.setDivision("offIddivision");
1838 officialIdentifier.setLevel("offIdlevel");
1839 officialIdentifier.setLongName("offIdlongName");
1840
1841 officialIdentifier.setShortName("offId-shortName-should-be-longer-than-twenty-characters");
1842 officialIdentifier.setVariation("offIdvariation");
1843 officialIdentifier.setSuffixCode("offIdsuffixcode");
1844 officialIdentifier.setOrgId("offIdorgid");
1845 clu.setOfficialIdentifier(officialIdentifier);
1846
1847 CluIdentifierInfo cluId1 = new CluIdentifierInfo();
1848 cluId1.setType("kuali.lu.type.CreditCourse.identifier.cross-listed");
1849 cluId1.setState("Sctive");
1850 cluId1.setCode("cluIdonecode");
1851 cluId1.setDivision("cluIdonedivision");
1852 cluId1.setLevel("cluIdonelevel");
1853 cluId1.setLongName("cluIdonelongName");
1854 cluId1.setShortName("cluIdoneshortName");
1855
1856
1857 cluId1.setSuffixCode("cl");
1858 cluId1.setOrgId("cluIdoneorgid");
1859
1860 clu.getAlternateIdentifiers().add(cluId1);
1861
1862 CluIdentifierInfo cluId2 = new CluIdentifierInfo();
1863
1864 cluId2.setType("kuali.lu.type.CreditCourse.identifier.version");
1865 cluId2.setState("Sctive");
1866 cluId2.setCode("cluIdtwocode");
1867 cluId2.setDivision("cluIdtwodivision");
1868 cluId2.setLevel("cluIdtwolevel");
1869 cluId2.setLongName("cluIdtwolongName");
1870 cluId2.setShortName("cluIdtwoshortName");
1871
1872
1873 cluId2.setVariation("ab");
1874 cluId2.setSuffixCode("cluIdtwosuffixcode");
1875
1876
1877 clu.getAlternateIdentifiers().add(cluId2);
1878
1879 clu.getAttributes().put("cluAttrKey1", "cluAttrValue1");
1880 clu.getAttributes().put("cluAttrKey2", "cluAttrValue2");
1881
1882 clu.setCanCreateLui(true);
1883
1884
1885 clu.setDefaultEnrollmentEstimate(-545);
1886 clu.setDefaultMaximumEnrollment(999);
1887
1888 RichTextInfo desc = new RichTextInfo();
1889 desc.setFormatted("<p>DESC FORMATTED</p>");
1890 desc.setPlain("DESC PLAIN");
1891 clu.setDescr(desc);
1892
1893 clu.setEffectiveDate(DF.parse("20100203"));
1894 clu.setExpirationDate(DF.parse("21001231"));
1895
1896 clu.setEnrollable(true);
1897
1898 AffiliatedOrgInfo aforg = new AffiliatedOrgInfo();
1899 aforg.setOrgId("AFFORGone");
1900 aforg.setPercentage(35l);
1901
1902 AffiliatedOrgInfo aforg1 = new AffiliatedOrgInfo();
1903 aforg1.setOrgId("AFForgtwo");
1904 aforg1.setPercentage(65l);
1905
1906 List<AffiliatedOrgInfo> affiliatedOrgs = new ArrayList<AffiliatedOrgInfo>();
1907 affiliatedOrgs.add(aforg);
1908 affiliatedOrgs.add(aforg1);
1909
1910 CurrencyAmountInfo ca = new CurrencyAmountInfo();
1911 ca.setCurrencyQuantity(100);
1912 ca.setCurrencyTypeKey("DLLR");
1913
1914 CurrencyAmountInfo ca1 = new CurrencyAmountInfo();
1915 ca.setCurrencyQuantity(200);
1916 ca.setCurrencyTypeKey("DLLR");
1917
1918 List<CurrencyAmountInfo> caList = new ArrayList<CurrencyAmountInfo>();
1919 caList.add(ca);
1920
1921 List<CurrencyAmountInfo> caList1 = new ArrayList<CurrencyAmountInfo>();
1922 caList.add(ca);
1923 caList.add(ca1);
1924
1925 RichTextInfo cfRecDesc = new RichTextInfo();
1926 cfRecDesc.setPlain("Clu Fee Record");
1927
1928 CluFeeRecordInfo feeRec = new CluFeeRecordInfo();
1929 feeRec.setAffiliatedOrgs(affiliatedOrgs);
1930 feeRec.setFeeAmounts(caList);
1931 feeRec.setFeeType("FEE-TYPE-X");
1932 feeRec.setRateType("RATE-TYPE-X");
1933 feeRec.setDescr(cfRecDesc);
1934
1935 CluFeeRecordInfo feeRec1 = new CluFeeRecordInfo();
1936 feeRec1.setAffiliatedOrgs(affiliatedOrgs);
1937 feeRec1.setFeeAmounts(caList1);
1938 feeRec1.setFeeType("FEE-TYPE-Y");
1939 feeRec1.setRateType("RATE-TYPE-Y");
1940
1941 List<CluFeeRecordInfo> feeRecList = new ArrayList<CluFeeRecordInfo>();
1942 feeRecList.add(feeRec);
1943 feeRecList.add(feeRec1);
1944
1945 RichTextInfo cfDesc = new RichTextInfo();
1946 cfDesc.setPlain("Clu Fee");
1947
1948 CluFeeInfo feeInfo = new CluFeeInfo();
1949 feeInfo.getAttributes().put("FeeAttrKey1", "FeeAttrValue1");
1950 feeInfo.getAttributes().put("FeeAttrKey2", "FeeAttrValue2");
1951 feeInfo.setCluFeeRecords(feeRecList);
1952 feeInfo.setDescr(cfDesc);
1953 clu.setFeeInfo(feeInfo);
1954
1955 clu.setHasEarlyDropDeadline(true);
1956
1957 clu.setHazardousForDisabledStudents(true);
1958
1959 CluInstructorInfo primaryInstructor = new CluInstructorInfo();
1960 primaryInstructor.setOrgId("EXTorgIdone");
1961 primaryInstructor.setPersonId("EXTpersonIdone");
1962 primaryInstructor.getAttributes().put("PrimaryInstAttrKey1",
1963 "PrimaryInstAttrValue1");
1964 primaryInstructor.getAttributes().put("PrimaryInstAttrKey2",
1965 "PrimaryInstAttrValue2");
1966 clu.setPrimaryInstructor(primaryInstructor);
1967
1968 CluInstructorInfo instructor1 = new CluInstructorInfo();
1969 instructor1.setOrgId("EXTorgIdtwo");
1970 instructor1.setPersonId("EXTpersonIdtwo");
1971 instructor1.getAttributes().put("Inst1AttrKey1", "Inst1AttrValue1");
1972 instructor1.getAttributes().put("Inst1AttrKey2", "Inst1AttrValue2");
1973 clu.getInstructors().add(instructor1);
1974
1975 CluInstructorInfo instructor2 = new CluInstructorInfo();
1976 instructor2.setOrgId("EXTorgIdthree");
1977 instructor2.setPersonId("EXTpersonIdthree");
1978 instructor2.getAttributes().put("Inst2AttrKey1", "Inst2AttrValue1");
1979 instructor2.getAttributes().put("Inst2AttrKey2", "Inst2AttrValue2");
1980 clu.getInstructors().add(instructor2);
1981
1982 LuCodeInfo luCode1 = new LuCodeInfo();
1983 luCode1.setId("luCode1.key");
1984 luCode1.setDescr("luCode1desc");
1985 luCode1.setValue("luCode1value");
1986 luCode1.getAttributes().put("luCode1AttrKey1", "luCode1AttrValue1");
1987 luCode1.getAttributes().put("luCode1AttrKey2", "luCode1AttrValue2");
1988 clu.getLuCodes().add(luCode1);
1989
1990 LuCodeInfo luCode2 = new LuCodeInfo();
1991 luCode2.setId("luCode2.key");
1992 luCode2.setDescr("luCodetwodesc");
1993 luCode2.setValue("luCodetwovalue");
1994 luCode2.getAttributes().put("luCode2AttrKey1", "luCode2AttrValue1");
1995 luCode2.getAttributes().put("luCode2AttrKey2", "luCode2AttrValue2");
1996 clu.getLuCodes().add(luCode2);
1997
1998 RichTextInfo marketingDesc = new RichTextInfo();
1999 marketingDesc.setFormatted("<p>marketingDesc FORMATTED</p>");
2000 marketingDesc.setPlain("marketingDesc PLAIN");
2001
2002 clu.setNextReviewPeriod("nextReviewPeriod");
2003
2004 clu.getOfferedAtpTypes().add("offeredAtpType1");
2005 clu.getOfferedAtpTypes().add("offeredAtpType2");
2006
2007
2008 CluInstructorInfo pubPrimaryInstructor = new CluInstructorInfo();
2009 pubPrimaryInstructor.setOrgId("EXTorgId");
2010 pubPrimaryInstructor.setPersonId("EXTpersonId");
2011 pubPrimaryInstructor.getAttributes().put("PubPrimaryInstAttrKey1",
2012 "PubPrimaryInstAttrValue1");
2013 pubPrimaryInstructor.getAttributes().put("PubPrimaryInstAttrKey2",
2014 "PubPrimaryInstAttrValue2");
2015
2016 CluInstructorInfo pubInstructor1 = new CluInstructorInfo();
2017 pubInstructor1.setOrgId("EXTorgIdtwo");
2018 pubInstructor1.setPersonId("EXT-personId-two");
2019 pubInstructor1.getAttributes().put("PubInst1AttrKey1",
2020 "PubInst1AttrValue1");
2021 pubInstructor1.getAttributes().put("PubInst1AttrKey2",
2022 "PubInst1AttrValue2");
2023
2024 CluInstructorInfo pubInstructor2 = new CluInstructorInfo();
2025 pubInstructor2.setOrgId("EXTorgIdthree");
2026 pubInstructor2.setPersonId("EXTpersonIdthree");
2027 pubInstructor2.getAttributes().put("PubInst2AttrKey1",
2028 "PubInst2AttrValue1");
2029 pubInstructor2.getAttributes().put("PubInst2AttrKey2",
2030 "PubInst2AttrValue2");
2031
2032 clu.setReferenceURL("http://student.kuali.org/clus");
2033
2034 TimeAmountInfo stdDuration = new TimeAmountInfo();
2035 stdDuration.setAtpDurationTypeKey("EXTstdDurationId");
2036 stdDuration.setTimeQuantity(new Integer(7867));
2037 clu.setStdDuration(stdDuration);
2038
2039 createCampusLocationList(clu);
2040
2041 createIntensity(clu);
2042
2043 createAccreditationList(clu);
2044
2045 createAdminOrgs(clu);
2046
2047 clu.setType("kuali.lu.type.CreditCourse");
2048 clu.setState("template");
2049
2050 List<ValidationResultInfo> valerros = client.validateClu("SYSTEM", clu);
2051
2052 assertEquals(2, valerros.size());
2053 }
2054
2055 @Test
2056 public void testAddCluToCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2057 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2058
2059 StatusInfo status = client.addCluToCluSet("CLU-1", createdCluSet.getId());
2060 CluSetInfo getCluSetInfo = client.getCluSetInfo(createdCluSet.getId());
2061
2062 assertTrue(status.getSuccess());
2063 assertEquals(1, getCluSetInfo.getCluIds().size());
2064 assertEquals("CLU-1", getCluSetInfo.getCluIds().get(0));
2065 }
2066
2067 @Test
2068 public void testAddCluToCluSet_DuplicateCluId() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2069 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2070
2071 StatusInfo status = client.addCluToCluSet("CLU-1", createdCluSet.getId());
2072 assertTrue(status.getSuccess());
2073
2074 status = client.addCluToCluSet("CLU-1", createdCluSet.getId());
2075 assertFalse(status.getSuccess());
2076 }
2077
2078 @Test
2079 public void testAddClusToCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2080 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2081
2082
2083
2084
2085
2086
2087
2088
2089 List<String> cluIdList = Arrays.asList(new String[] {"CLU-1", "CLU-2", "CLU-3", "CLU-4"});
2090
2091 StatusInfo status = client.addClusToCluSet(cluIdList, createdCluSet.getId());
2092 CluSetInfo getCluSetInfo = client.getCluSetInfo(createdCluSet.getId());
2093 assertTrue(status.getSuccess());
2094 assertEquals(4, getCluSetInfo.getCluIds().size());
2095 assertTrue(getCluSetInfo.getCluIds().contains("CLU-1"));
2096 assertTrue(getCluSetInfo.getCluIds().contains("CLU-2"));
2097 assertTrue(getCluSetInfo.getCluIds().contains("CLU-3"));
2098 assertTrue(getCluSetInfo.getCluIds().contains("CLU-4"));
2099 }
2100
2101 @Test
2102 public void testAddClusToCluSet_InvalidCluId() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2103 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2104
2105 List<String> cluIdList = Arrays.asList(new String[] {"CLU-1", "CLU-2", "CLU-INVALID-ID", "CLU-4"});
2106
2107 try {
2108 client.addClusToCluSet(cluIdList, createdCluSet.getId());
2109 fail("Adding a non-existent CLU (id='CLU-INVALID-ID') to CluSet should have failed");
2110 } catch(DoesNotExistException e) {
2111 assertTrue(true);
2112 }
2113 }
2114
2115 @Test
2116 public void testAddClusToCluSet_DuplicateCluId() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2117 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2118
2119 List<String> cluIdList = Arrays.asList(new String[] {"CLU-1", "CLU-2", "CLU-2", "CLU-4"});
2120
2121 StatusInfo status = client.addClusToCluSet(cluIdList, createdCluSet.getId());
2122 assertEquals("CluSet already contains Clu (id='CLU-2')", status.getMessage());
2123 }
2124
2125 @Test
2126 public void testAddClusToCluSet_InvalidCluSetId() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2127 List<String> cluIdList = Arrays.asList(new String[] {"CLU-1", "CLU-2", "CLU-3", "CLU-4"});
2128
2129 try {
2130 client.addClusToCluSet(cluIdList, "CLUSET-INVALID-ID");
2131 fail("Adding CLUs to a non-existent CluSet (id='CLUSET-INVALID-ID') should have failed");
2132 } catch(DoesNotExistException e) {
2133 assertTrue(true);
2134 }
2135 }
2136
2137 @Test
2138 public void testAddCluSetToCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2139 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2140
2141 StatusInfo status = client.addCluSetToCluSet(createdCluSet.getId(), "CLUSET-1");
2142 CluSetInfo getCluSetInfo = client.getCluSetInfo(createdCluSet.getId());
2143
2144 assertTrue(status.getSuccess());
2145 assertEquals(1, getCluSetInfo.getCluSetIds().size());
2146 assertTrue(getCluSetInfo.getCluSetIds().contains("CLUSET-1"));
2147 }
2148
2149 @Test
2150 public void testAddCluSetToCluSet_CircularRelationshipException() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2151 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2152
2153 try {
2154 client.addCluSetToCluSet(createdCluSet.getId(), createdCluSet.getId());
2155 fail("Adding a CluSet to itself should have failed");
2156 } catch(CircularRelationshipException e) {
2157 assertTrue(true);
2158 }
2159 }
2160
2161 @Test
2162 public void testAddCluSetToCluSet_NestedCircularRelationshipException() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2163 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2164 CluSetInfo createdCluSet2 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2165 CluSetInfo createdCluSet3 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2166
2167 client.addCluSetToCluSet(createdCluSet3.getId(), createdCluSet1.getId());
2168 client.addCluSetToCluSet(createdCluSet2.getId(), createdCluSet3.getId());
2169
2170 try {
2171 client.addCluSetToCluSet(createdCluSet1.getId(), createdCluSet2.getId());
2172 fail("Adding CluSet should have thrown a CircularRelationshipException");
2173 } catch(CircularRelationshipException e) {
2174 assertTrue(true);
2175 }
2176 }
2177
2178 @Test
2179 public void testAddCluSetToCluSet_DuplicateCluSetId() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2180 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2181
2182 StatusInfo status = client.addCluSetToCluSet(createdCluSet.getId(), "CLUSET-1");
2183 assertTrue(status.getSuccess());
2184
2185 try {
2186 client.addCluSetToCluSet(createdCluSet.getId(), "CLUSET-1");
2187 fail("Adding a duplicate CluSet (id='CLUSET-1') to CluSet should have failed");
2188 } catch(OperationFailedException e) {
2189 assertTrue(true);
2190 }
2191 }
2192
2193 @Test
2194 public void testAddCluSetToCluSet_InvalidCluSetId() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2195 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2196
2197 try {
2198 client.addCluSetToCluSet(createdCluSet.getId(), "CLUSET-INVALID-ID");
2199 fail("Adding a non-existent CluSet (id='CLUSET-INVALID-ID') to CluSet should have failed");
2200 } catch(DoesNotExistException e) {
2201 assertTrue(true);
2202 }
2203 }
2204
2205 @Test
2206 public void testAddCluSetsToCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2207 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2208
2209 List<String> cluIdList = Arrays.asList(new String[] {"CLUSET-1", "CLUSET-2", "CLUSET-3", "CLUSET-4"});
2210
2211 StatusInfo status = client.addCluSetsToCluSet(createdCluSet.getId(), cluIdList);
2212 CluSetInfo getCluSetInfo = client.getCluSetInfo(createdCluSet.getId());
2213
2214 assertTrue(status.getSuccess());
2215 assertEquals(4, getCluSetInfo.getCluSetIds().size());
2216 assertTrue(getCluSetInfo.getCluSetIds().contains("CLUSET-1"));
2217 assertTrue(getCluSetInfo.getCluSetIds().contains("CLUSET-2"));
2218 assertTrue(getCluSetInfo.getCluSetIds().contains("CLUSET-3"));
2219 assertTrue(getCluSetInfo.getCluSetIds().contains("CLUSET-4"));
2220 }
2221
2222 @Test
2223 public void testAddCluSetsToCluSet_InvalidCluSetId() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2224 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2225
2226 List<String> cluIdList = Arrays.asList(new String[] {"CLUSET-1", "CLUSET-INVALID-ID", "CLUSET-3", "CLUSET-4"});
2227
2228 try {
2229 client.addCluSetsToCluSet(createdCluSet.getId(), cluIdList);
2230 fail("Adding a non-existent CluSet (id='CLUSET-INVALID-ID') to CluSet should have failed");
2231 } catch(DoesNotExistException e) {
2232 assertTrue(true);
2233 }
2234 }
2235
2236 @Test
2237 public void testAddCluSetsToCluSet_DuplicateCluSetId() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2238 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2239
2240 List<String> cluIdList = Arrays.asList(new String[] {"CLUSET-1", "CLUSET-2", "CLUSET-3", "CLUSET-2"});
2241
2242 try {
2243 client.addCluSetsToCluSet(createdCluSet.getId(), cluIdList);
2244 fail("Adding a duplicate CluSet (id='CLUSET-2') to CluSet should have failed");
2245 } catch(OperationFailedException e) {
2246 assertTrue(true);
2247 }
2248 }
2249
2250 @Test
2251 public void testAddCluSetsToCluSet_CircularRelationshipException() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2252 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2253
2254 List<String> cluIdList = Arrays.asList(new String[] {"CLUSET-1", "CLUSET-2", createdCluSet.getId(), "CLUSET-4"});
2255
2256 try {
2257 client.addCluSetsToCluSet(createdCluSet.getId(), cluIdList);
2258 fail("Adding a CluSet to itself should have failed");
2259 } catch(CircularRelationshipException e) {
2260 assertTrue(true);
2261 }
2262 }
2263
2264 @Test
2265 public void testAddCluSetsToCluSet_NestedCircularRelationshipException() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, CircularRelationshipException {
2266 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2267 CluSetInfo createdCluSet2 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2268 CluSetInfo createdCluSet3 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSetInfo());
2269
2270 List<String> cluIdList1 = Arrays.asList(new String[] {"CLUSET-1", "CLUSET-2", createdCluSet1.getId()});
2271 client.addCluSetsToCluSet(createdCluSet3.getId(), cluIdList1);
2272
2273
2274 List<String> cluIdList2 = Arrays.asList(new String[] {"CLUSET-1",createdCluSet3.getId()});
2275 client.addCluSetsToCluSet(createdCluSet2.getId(), cluIdList2);
2276
2277 try {
2278 List<String> cluIdList3 = Arrays.asList(new String[] {createdCluSet2.getId(),});
2279 client.addCluSetsToCluSet(createdCluSet1.getId(), cluIdList3);
2280 fail("Adding CluSet should have thrown a CircularRelationshipException");
2281 } catch(CircularRelationshipException e) {
2282 assertTrue(true);
2283 }
2284 }
2285
2286 @Test
2287 public void testCreateDynamicCluSet_Simple() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2288 CluSetInfo cluSet = createCluSetInfo();
2289
2290 MembershipQueryInfo query = new MembershipQueryInfo();
2291 query.setSearchTypeKey("lu.search.clus");
2292
2293 cluSet.setMembershipQuery(query);
2294 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet);
2295
2296 assertNotNull(createdCluSet);
2297 assertNotNull(createdCluSet.getMembershipQuery());
2298 assertNotNull(createdCluSet.getMembershipQuery().getId());
2299 assertNotNull(createdCluSet.getMembershipQuery().getSearchTypeKey());
2300 assertEquals(query.getSearchTypeKey(), createdCluSet.getMembershipQuery().getSearchTypeKey());
2301 assertNotNull(createdCluSet.getMembershipQuery().getQueryParamValueList());
2302 assertNotNull(createdCluSet.getCluIds());
2303 assertEquals(107, createdCluSet.getCluIds().size());
2304 }
2305
2306 private MembershipQueryInfo getMembershipQueryInfo() {
2307 List<SearchParam> queryParamValues = new ArrayList<SearchParam>();
2308 SearchParam sp1 = new SearchParam();
2309 sp1.setKey("lu.queryParam.startsWith.cluCode");
2310 sp1.setValue("AAST");
2311 queryParamValues.add(sp1);
2312 SearchParam sp2 = new SearchParam();
2313 sp2.setKey("lu.queryParam.cluState");
2314 sp2.setValue("Active");
2315 queryParamValues.add(sp2);
2316
2317 MembershipQueryInfo query = new MembershipQueryInfo();
2318 query.setSearchTypeKey("lu.search.cluByCodeAndState");
2319 query.setQueryParamValueList(queryParamValues);
2320
2321 return query;
2322 }
2323
2324 @Test
2325 public void testCreateDynamicCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2326 CluSetInfo cluSet = createCluSetInfo();
2327
2328 MembershipQueryInfo query = getMembershipQueryInfo();
2329 cluSet.setMembershipQuery(query);
2330
2331 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet);
2332
2333 assertNotNull(createdCluSet);
2334 assertNotNull(createdCluSet.getMembershipQuery());
2335 assertNotNull(createdCluSet.getMembershipQuery().getId());
2336 assertNotNull(createdCluSet.getMembershipQuery().getSearchTypeKey());
2337 assertEquals(query.getSearchTypeKey(), createdCluSet.getMembershipQuery().getSearchTypeKey());
2338 assertNotNull(createdCluSet.getMembershipQuery().getQueryParamValueList());
2339 assertEquals(query.getQueryParamValueList().size(), createdCluSet.getMembershipQuery().getQueryParamValueList().size());
2340 assertNotNull(createdCluSet.getCluIds());
2341 assertEquals(10, createdCluSet.getCluIds().size());
2342
2343 CluSetInfo getCluSet = client.getCluSetInfo(createdCluSet.getId());
2344
2345 assertNotNull(getCluSet);
2346 assertNotNull(getCluSet.getMembershipQuery());
2347 assertNotNull(getCluSet.getMembershipQuery().getId());
2348 assertNotNull(getCluSet.getMembershipQuery().getSearchTypeKey());
2349 assertEquals(query.getSearchTypeKey(), getCluSet.getMembershipQuery().getSearchTypeKey());
2350 assertNotNull(getCluSet.getMembershipQuery().getQueryParamValueList());
2351 assertEquals(query.getQueryParamValueList().size(), getCluSet.getMembershipQuery().getQueryParamValueList().size());
2352 assertNotNull(getCluSet.getCluIds());
2353 assertEquals(10, getCluSet.getCluIds().size());
2354 }
2355
2356 @Test
2357 public void testCreateCluSet_InvalidCluSet1() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2358 CluSetInfo cluSet = createCluSetInfo();
2359 cluSet.getCluIds().add("CLU-1");
2360
2361 MembershipQueryInfo query = new MembershipQueryInfo();
2362 query.setSearchTypeKey("lu.search.clus");
2363
2364 cluSet.setMembershipQuery(query);
2365
2366 try {
2367 client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet);
2368 fail("Creating CluSet should have thrown an UnsupportedActionException. Cannot add CLUs and Dynamic CluSets into one CluSet");
2369 } catch (UnsupportedActionException e) {
2370 assertTrue(true);
2371 }
2372
2373 }
2374
2375 @Test
2376 public void testCreateCluSet_InvalidCluSet2() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2377 CluSetInfo cluSet = createCluSetInfo();
2378 cluSet.getCluSetIds().add("CLUSET-1");
2379
2380 MembershipQueryInfo query = new MembershipQueryInfo();
2381 query.setSearchTypeKey("lu.search.clus");
2382
2383 cluSet.setMembershipQuery(query);
2384
2385 try {
2386 client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet);
2387 fail("Creating CluSet should have thrown an UnsupportedActionException. Cannot add CluSets and Dynamic CluSets into one CluSet");
2388 } catch (UnsupportedActionException e) {
2389 assertTrue(true);
2390 }
2391
2392 }
2393
2394 @Test
2395 public void testCreateCluSet_InvalidCluSet3() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2396 CluSetInfo cluSet = createCluSetInfo();
2397 cluSet.getCluIds().add("CLU-1");
2398 cluSet.getCluSetIds().add("CLUSET-1");
2399
2400 try {
2401 client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet);
2402 fail("Creating CluSet should have thrown an UnsupportedActionException. Cannot add CLUs and CluSets into one CluSet");
2403 } catch (UnsupportedActionException e) {
2404 assertTrue(true);
2405 }
2406
2407 }
2408
2409 @Test
2410 public void testGetDynamicCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2411 CluSetInfo cluSet = createCluSetInfo();
2412
2413 MembershipQueryInfo query = getMembershipQueryInfo();
2414 cluSet.setMembershipQuery(query);
2415 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet);
2416 assertNotNull(createdCluSet);
2417 assertNotNull(createdCluSet.getCluIds());
2418
2419 CluSetInfo getCluSet = client.getCluSetInfo(createdCluSet.getId());
2420
2421 assertNotNull(getCluSet);
2422 assertNotNull(getCluSet.getMembershipQuery());
2423 assertNotNull(getCluSet.getMembershipQuery().getId());
2424 assertNotNull(getCluSet.getMembershipQuery().getSearchTypeKey());
2425 assertEquals(query.getSearchTypeKey(), getCluSet.getMembershipQuery().getSearchTypeKey());
2426 assertNotNull(getCluSet.getMembershipQuery().getQueryParamValueList());
2427 assertEquals(query.getQueryParamValueList().size(), getCluSet.getMembershipQuery().getQueryParamValueList().size());
2428 assertEquals(createdCluSet.getCluIds().size(), getCluSet.getCluIds().size());
2429 assertNotNull(getCluSet.getCluIds());
2430 assertEquals(10, getCluSet.getCluIds().size());
2431 }
2432
2433 @Test
2434 public void testGetDynamicCluSet_Simple() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException {
2435 CluSetInfo cluSet = createCluSetInfo();
2436
2437 MembershipQueryInfo query = new MembershipQueryInfo();
2438 query.setSearchTypeKey("lu.search.clus");
2439
2440 cluSet.setMembershipQuery(query);
2441 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet);
2442 assertNotNull(createdCluSet);
2443 assertNotNull(createdCluSet.getCluIds());
2444
2445 CluSetInfo getCluSet = client.getCluSetInfo(createdCluSet.getId());
2446 assertNotNull(getCluSet);
2447 assertNotNull(getCluSet.getCluIds());
2448 assertEquals(createdCluSet.getCluIds().size(), getCluSet.getCluIds().size());
2449 }
2450
2451 @Test
2452 public void testGetCluSetTreeView() throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
2453 CluSetTreeViewInfo treeView = client.getCluSetTreeView("CLUSET-2");
2454 assertNotNull(treeView);
2455 assertEquals(2, treeView.getCluSets().size());
2456
2457 CluSetTreeViewInfo cluSet = treeView.getCluSets().get(1);
2458 assertNotNull(cluSet);
2459 assertEquals("CLUSET-4", cluSet.getId());
2460 assertEquals(2, cluSet.getClus().size());
2461
2462 CluInfo clu = cluSet.getClus().get(1);
2463 assertNotNull(clu);
2464 assertEquals("CLU-3", clu.getId());
2465 }
2466
2467 @Test
2468 public void testGetCluSetTreeView_dynamicCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, UnsupportedActionException, DoesNotExistException {
2469 CluSetInfo cluSet = createCluSetInfo();
2470
2471 MembershipQueryInfo query = new MembershipQueryInfo();
2472 query.setSearchTypeKey("lu.search.clus");
2473
2474 cluSet.setMembershipQuery(query);
2475 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet);
2476 assertNotNull(createdCluSet);
2477 assertNotNull(createdCluSet.getCluIds());
2478
2479 CluSetTreeViewInfo treeView = client.getCluSetTreeView(createdCluSet.getId());
2480 assertNotNull(treeView);
2481 assertEquals(createdCluSet.getCluIds().size(), treeView.getClus().size());
2482 }
2483
2484 @Test
2485 public void testGetCluSetTreeView_invalidCluSet()
2486 throws InvalidParameterException, MissingParameterException,
2487 OperationFailedException, PermissionDeniedException {
2488 try {
2489 client.getCluSetTreeView("CLUSET-XX");
2490 assertTrue(false);
2491 } catch (DoesNotExistException e) {
2492 assertTrue(true);
2493 }
2494 }
2495
2496 @Test
2497 public void testGetCluSetTreeView_nullCluSet()
2498 throws DoesNotExistException, InvalidParameterException,
2499 OperationFailedException, PermissionDeniedException {
2500 try {
2501 client.getCluSetTreeView(null);
2502 assertTrue(false);
2503 } catch (MissingParameterException e) {
2504 assertTrue(true);
2505 }
2506 }
2507
2508 @Test
2509 public void testUpdateDynamicCluSet() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, VersionMismatchException, UnsupportedActionException, CircularRelationshipException {
2510 CluSetInfo cluSet1 = createCluSetInfo();
2511
2512
2513 List<SearchParam> queryParamValues1 = new ArrayList<SearchParam>();
2514 MembershipQueryInfo query1 = new MembershipQueryInfo();
2515 query1.setSearchTypeKey("lu.search.clus");
2516 query1.setQueryParamValueList(queryParamValues1);
2517
2518 cluSet1.setMembershipQuery(query1);
2519
2520 CluSetInfo createdCluSet = client.createCluSet("kuali.cluSet.type.CreditCourse", cluSet1);
2521
2522
2523
2524 MembershipQueryInfo query2 = getMembershipQueryInfo();
2525
2526 createdCluSet.setMembershipQuery(query2);
2527
2528
2529 createdCluSet.getCluSetIds().clear();
2530 createdCluSet.getCluIds().clear();
2531 CluSetInfo updatedCluSet = client.updateCluSet(createdCluSet.getId(), createdCluSet);
2532
2533 assertNotNull(updatedCluSet);
2534 assertNotNull(updatedCluSet.getCluIds());
2535 assertEquals(10, updatedCluSet.getCluIds().size());
2536 assertTrue(updatedCluSet.getCluSetIds().isEmpty());
2537 }
2538
2539 @Test
2540 public void testUpdateCluSet_VersionMismatch() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, VersionMismatchException, CircularRelationshipException {
2541 CluSetInfo createCluSet = createCluSetInfo();
2542
2543 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
2544 createdCluSet1.getCluSetIds().add("CLUSET-1");
2545 createdCluSet1.getCluSetIds().add("CLUSET-2");
2546
2547 CluSetInfo updatedCluSet1 = client.updateCluSet(createdCluSet1.getId(), createdCluSet1);
2548 assertEquals(2, updatedCluSet1.getCluSetIds().size());
2549
2550 try {
2551 client.updateCluSet(updatedCluSet1.getId(), createdCluSet1);
2552 fail("Should have thrown VersionMismatchException.");
2553 } catch (VersionMismatchException e) {
2554 assertTrue(true);
2555 }
2556 }
2557
2558 @Test
2559 public void testUpdateCluSet_ClearCluSets() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, VersionMismatchException, CircularRelationshipException {
2560 CluSetInfo createCluSet = createCluSetInfo();
2561 createCluSet.getCluSetIds().add("CLUSET-1");
2562 createCluSet.getCluSetIds().add("CLUSET-2");
2563 createCluSet.getCluSetIds().add("CLUSET-3");
2564
2565 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
2566 assertEquals(3, createdCluSet1.getCluSetIds().size());
2567
2568 createdCluSet1.getCluSetIds().clear();
2569
2570 CluSetInfo updatedCluSet1 = client.updateCluSet(createdCluSet1.getId(), createdCluSet1);
2571 assertEquals(0, updatedCluSet1.getCluSetIds().size());
2572
2573 CluSetInfo getCluSet1 = client.getCluSetInfo(updatedCluSet1.getId());
2574 assertEquals(0, getCluSet1.getCluSetIds().size());
2575 }
2576
2577 @Test
2578 public void testUpdateCluSet_AddCluSets() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, VersionMismatchException, CircularRelationshipException {
2579 CluSetInfo createCluSet = createCluSetInfo();
2580
2581 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
2582 assertEquals(0, createdCluSet1.getCluSetIds().size());
2583
2584 createdCluSet1.getCluSetIds().add("CLUSET-1");
2585 createdCluSet1.getCluSetIds().add("CLUSET-2");
2586
2587 CluSetInfo updatedCluSet1 = client.updateCluSet(createdCluSet1.getId(), createdCluSet1);
2588 assertEquals(2, updatedCluSet1.getCluSetIds().size());
2589
2590 CluSetInfo getCluSet1 = client.getCluSetInfo(updatedCluSet1.getId());
2591 assertEquals(2, getCluSet1.getCluSetIds().size());
2592 assertTrue(getCluSet1.getCluSetIds().contains("CLUSET-1"));
2593 assertTrue(getCluSet1.getCluSetIds().contains("CLUSET-2"));
2594 }
2595
2596 @Test
2597 public void testUpdateCluSet_removeCluSets() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, VersionMismatchException, CircularRelationshipException {
2598 CluSetInfo createCluSet = createCluSetInfo();
2599 createCluSet.getCluSetIds().add("CLUSET-1");
2600 createCluSet.getCluSetIds().add("CLUSET-2");
2601 createCluSet.getCluSetIds().add("CLUSET-3");
2602
2603 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
2604 assertEquals(3, createdCluSet1.getCluSetIds().size());
2605
2606 createdCluSet1.getCluSetIds().remove("CLUSET-2");
2607
2608 CluSetInfo updatedCluSet1 = client.updateCluSet(createdCluSet1.getId(), createdCluSet1);
2609 assertEquals(2, updatedCluSet1.getCluSetIds().size());
2610
2611 CluSetInfo getCluSet1 = client.getCluSetInfo(updatedCluSet1.getId());
2612 assertEquals(2, getCluSet1.getCluSetIds().size());
2613 assertTrue(getCluSet1.getCluSetIds().contains("CLUSET-1"));
2614 assertTrue(getCluSet1.getCluSetIds().contains("CLUSET-3"));
2615 }
2616
2617 @Test
2618 public void testUpdateCluSet_ClearClus() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, VersionMismatchException, CircularRelationshipException {
2619 CluSetInfo createCluSet = createCluSetInfo();
2620 createCluSet.getCluIds().add("CLU-1");
2621 createCluSet.getCluIds().add("CLU-2");
2622 assertEquals(2, createCluSet.getCluIds().size());
2623
2624 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
2625 assertEquals(2, createdCluSet1.getCluIds().size());
2626
2627 assertNotNull(createdCluSet1);
2628 assertNotNull(createdCluSet1.getCluIds());
2629 assertEquals(2, createdCluSet1.getCluIds().size());
2630
2631
2632 createdCluSet1.getCluIds().clear();
2633
2634 CluSetInfo updatedCluSet1 = client.updateCluSet(createdCluSet1.getId(), createdCluSet1);
2635
2636 assertNotNull(updatedCluSet1);
2637 assertNotNull(updatedCluSet1.getCluIds());
2638 assertEquals(0, updatedCluSet1.getCluIds().size());
2639
2640 CluSetInfo getCluSet1 = client.getCluSetInfo(updatedCluSet1.getId());
2641
2642 assertNotNull(getCluSet1);
2643 assertNotNull(getCluSet1.getCluIds());
2644 assertEquals(0, getCluSet1.getCluIds().size());
2645 }
2646
2647 @Test
2648 public void testUpdateCluSet_AddClu() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, VersionMismatchException, CircularRelationshipException {
2649 CluSetInfo createCluSet = createCluSetInfo();
2650 createCluSet.getCluIds().add("CLU-1");
2651 createCluSet.getCluIds().add("CLU-2");
2652 assertEquals(2, createCluSet.getCluIds().size());
2653
2654 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
2655 assertEquals(2, createdCluSet1.getCluIds().size());
2656
2657 createdCluSet1.getCluIds().add("CLU-3");
2658
2659 assertNotNull(createdCluSet1);
2660 assertNotNull(createdCluSet1.getCluIds());
2661 assertEquals(3, createdCluSet1.getCluIds().size());
2662
2663 CluSetInfo updatedCluSet1 = client.updateCluSet(createdCluSet1.getId(), createdCluSet1);
2664
2665 assertNotNull(updatedCluSet1);
2666 assertNotNull(updatedCluSet1.getCluIds());
2667 assertEquals(3, updatedCluSet1.getCluIds().size());
2668
2669 CluSetInfo getCluSet1 = client.getCluSetInfo(updatedCluSet1.getId());
2670
2671 assertNotNull(getCluSet1);
2672 assertNotNull(getCluSet1.getCluIds());
2673 assertEquals(3, getCluSet1.getCluIds().size());
2674 }
2675
2676 @Test
2677 public void testUpdateCluSet_RemoveClu() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, UnsupportedActionException, VersionMismatchException, CircularRelationshipException {
2678 CluSetInfo createCluSet = createCluSetInfo();
2679 createCluSet.getCluIds().add("CLU-1");
2680 createCluSet.getCluIds().add("CLU-2");
2681 assertEquals(2, createCluSet.getCluIds().size());
2682
2683 CluSetInfo createdCluSet1 = client.createCluSet("kuali.cluSet.type.CreditCourse", createCluSet);
2684 assertEquals(2, createdCluSet1.getCluIds().size());
2685
2686 createdCluSet1.getCluIds().remove("CLU-1");
2687
2688 assertNotNull(createdCluSet1);
2689 assertNotNull(createdCluSet1.getCluIds());
2690 assertEquals(1, createdCluSet1.getCluIds().size());
2691
2692 CluSetInfo updatedCluSet1 = client.updateCluSet(createdCluSet1.getId(), createdCluSet1);
2693
2694 assertNotNull(updatedCluSet1);
2695 assertNotNull(updatedCluSet1.getCluIds());
2696 assertEquals(1, updatedCluSet1.getCluIds().size());
2697 assertTrue(updatedCluSet1.getCluIds().contains("CLU-2"));
2698
2699 CluSetInfo getCluSet1 = client.getCluSetInfo(updatedCluSet1.getId());
2700
2701 assertNotNull(getCluSet1);
2702 assertNotNull(getCluSet1.getCluIds());
2703 assertEquals(1, getCluSet1.getCluIds().size());
2704 }
2705
2706 @Test
2707 public void testCreateCluResult() throws AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException {
2708 CluResultInfo dto = new CluResultInfo();
2709 RichTextInfo desc = new RichTextInfo();
2710 desc.setPlain("Plain description");
2711 dto.setDesc(desc);
2712 dto.setCluId("CLU-1");
2713 dto.setState("active");
2714 dto.setType("kuali.resultType.gradeCourseResult");
2715 dto.setEffectiveDate(new Date());
2716 dto.setExpirationDate(new Date());
2717
2718 CluResultInfo cluResult = client.createCluResult("CLU-1", "kuali.resultType.gradeCourseResult", dto);
2719
2720 assertNotNull(cluResult);
2721 assertNotNull(cluResult.getDesc());
2722 assertEquals(dto.getDesc().getPlain(), cluResult.getDesc().getPlain());
2723 assertNotNull(cluResult.getId());
2724 assertNotNull(cluResult.getCluId());
2725 assertEquals(dto.getCluId(), cluResult.getCluId());
2726 assertNotNull(cluResult.getType());
2727 assertEquals(dto.getType(), cluResult.getType());
2728 assertEquals(dto.getEffectiveDate(), cluResult.getEffectiveDate());
2729 assertEquals(dto.getExpirationDate(), cluResult.getExpirationDate());
2730 }
2731
2732 @Test
2733 public void testUpdateCluResult() throws AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, VersionMismatchException {
2734 CluResultInfo dto = new CluResultInfo();
2735 RichTextInfo desc1 = new RichTextInfo();
2736 desc1.setPlain("Plain description");
2737 dto.setDesc(desc1);
2738 dto.setCluId("CLU-1");
2739 dto.setState("Suspended");
2740 dto.setType("kuali.resultType.gradeCourseResult");
2741 dto.setEffectiveDate(new Date());
2742 dto.setExpirationDate(new Date());
2743
2744 List<ResultOptionInfo> resultOptions = new ArrayList<ResultOptionInfo>();
2745 ResultOptionInfo option = new ResultOptionInfo();
2746 RichTextInfo desc2 = new RichTextInfo();
2747 desc2.setPlain("Plain description");
2748 option.setDesc(desc2);
2749 option.setEffectiveDate(new Date());
2750 option.setExpirationDate(new Date());
2751 option.setResultComponentId("kuali.resultComponent.grade.letter");
2752 option.setResultUsageTypeKey(null);
2753 option.setState("Suspended");
2754 resultOptions.add(option);
2755
2756 dto.setResultOptions(resultOptions);
2757
2758 CluResultInfo createCluResult = client.createCluResult("CLU-1", "kuali.resultType.gradeCourseResult", dto);
2759 createCluResult = client.getCluResult(createCluResult.getId());
2760
2761 assertNotNull(createCluResult);
2762
2763 createCluResult.setCluId("CLU-2");
2764 RichTextInfo desc3 = new RichTextInfo();
2765 desc3.setPlain("Plain description again");
2766 createCluResult.setDesc(desc3);
2767 createCluResult.setEffectiveDate(new Date());
2768 createCluResult.setExpirationDate(new Date());
2769 createCluResult.setState("active");
2770 createCluResult.setType("kuali.resultType.creditCourseResult");
2771
2772 RichTextInfo desc4 = new RichTextInfo();
2773 desc4.setPlain("Some more plain description");
2774 createCluResult.getResultOptions().get(0).setDesc(desc4);
2775 createCluResult.getResultOptions().get(0).setEffectiveDate(new Date());
2776 createCluResult.getResultOptions().get(0).setExpirationDate(new Date());
2777 createCluResult.getResultOptions().get(0).setResultComponentId("kuali.resultComponent.grade.passFail");
2778 createCluResult.getResultOptions().get(0).setResultUsageTypeKey("lrType.finalGrade");
2779 createCluResult.getResultOptions().get(0).setState("active");
2780
2781 CluResultInfo updateCluResult = client.updateCluResult(createCluResult.getId(), createCluResult);
2782 updateCluResult = client.getCluResult(updateCluResult.getId());
2783
2784 assertNotNull(updateCluResult);
2785 assertEquals(createCluResult.getId(), updateCluResult.getId());
2786 assertEquals(createCluResult.getDesc().getPlain(), updateCluResult.getDesc().getPlain());
2787 assertEquals(createCluResult.getEffectiveDate(), updateCluResult.getEffectiveDate());
2788 assertEquals(createCluResult.getExpirationDate(), updateCluResult.getExpirationDate());
2789 assertEquals(createCluResult.getState(), updateCluResult.getState());
2790 assertEquals(createCluResult.getType(), updateCluResult.getType());
2791 assertEquals(createCluResult.getResultOptions().get(0).getId(), updateCluResult.getResultOptions().get(0).getId());
2792 assertEquals(createCluResult.getResultOptions().get(0).getDesc().getPlain(), updateCluResult.getResultOptions().get(0).getDesc().getPlain());
2793 assertEquals(createCluResult.getResultOptions().get(0).getEffectiveDate(), updateCluResult.getResultOptions().get(0).getEffectiveDate());
2794 assertEquals(createCluResult.getResultOptions().get(0).getExpirationDate(), updateCluResult.getResultOptions().get(0).getExpirationDate());
2795 assertEquals(createCluResult.getResultOptions().get(0).getResultComponentId(), updateCluResult.getResultOptions().get(0).getResultComponentId());
2796 assertEquals(createCluResult.getResultOptions().get(0).getResultUsageTypeKey(), updateCluResult.getResultOptions().get(0).getResultUsageTypeKey());
2797 assertEquals(createCluResult.getResultOptions().get(0).getState(), updateCluResult.getResultOptions().get(0).getState());
2798 }
2799
2800 @Test
2801 public void testUpdateCluResult_RemoveAllCluResultOptions() throws AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, VersionMismatchException {
2802 CluResultInfo dto = new CluResultInfo();
2803 RichTextInfo desc1 = new RichTextInfo();
2804 desc1.setPlain("Plain description");
2805 dto.setDesc(desc1);
2806 dto.setCluId("CLU-1");
2807 dto.setState("Suspended");
2808 dto.setType("kuali.resultType.gradeCourseResult");
2809 dto.setEffectiveDate(new Date());
2810 dto.setExpirationDate(new Date());
2811
2812 List<ResultOptionInfo> resultOptions = new ArrayList<ResultOptionInfo>();
2813 ResultOptionInfo option = new ResultOptionInfo();
2814 RichTextInfo desc2 = new RichTextInfo();
2815 desc2.setPlain("Plain description");
2816 option.setDesc(desc2);
2817 option.setEffectiveDate(new Date());
2818 option.setExpirationDate(new Date());
2819 option.setResultComponentId("kuali.resultComponent.grade.letter");
2820
2821 option.setState("Suspended");
2822 resultOptions.add(option);
2823
2824 dto.setResultOptions(resultOptions);
2825
2826 CluResultInfo createCluResult = client.createCluResult("CLU-1", "kuali.resultType.gradeCourseResult", dto);
2827 createCluResult = client.getCluResult(createCluResult.getId());
2828
2829 assertNotNull(createCluResult);
2830
2831
2832 createCluResult.getResultOptions().clear();
2833
2834 CluResultInfo updateCluResult = client.updateCluResult(createCluResult.getId(), createCluResult);
2835 updateCluResult = client.getCluResult(updateCluResult.getId());
2836
2837 assertNotNull(updateCluResult);
2838 assertEquals(createCluResult.getId(), updateCluResult.getId());
2839 assertEquals(createCluResult.getResultOptions().isEmpty(), updateCluResult.getResultOptions().isEmpty());
2840 }
2841
2842 @Test
2843 public void testVersioning() throws ParseException, AlreadyExistsException, DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException, IllegalVersionSequencingException{
2844 CluInfo clu = createCluInfo();
2845 clu.setType("luType.shell.course");
2846 CluInfo cluV1 = client.createClu(clu.getType(), clu);
2847
2848 try{
2849
2850 client.setCurrentCluVersion(cluV1.getId(), DF.parse("19000101"));
2851 assertTrue(false);
2852 }catch(Exception e){}
2853
2854 CluInfo justMadeCurrentClu = client.getClu(cluV1.getId());
2855 assertTrue(justMadeCurrentClu.getVersionInfo().getCurrentVersionStart().compareTo(new Date())<1);
2856 VersionDisplayInfo versionDisplayInfo = client.getCurrentVersion(LuServiceConstants.CLU_NAMESPACE_URI, justMadeCurrentClu.getVersionInfo().getVersionIndId());
2857
2858 CluInfo cluV2 = client.createNewCluVersion(cluV1.getVersionInfo().getVersionIndId(),"CommentA");
2859 CluInfo cluV3 = client.createNewCluVersion(cluV1.getVersionInfo().getVersionIndId(),"CommentB");
2860 versionDisplayInfo = client.getCurrentVersion(LuServiceConstants.CLU_NAMESPACE_URI, cluV1.getVersionInfo().getVersionIndId());
2861 assertEquals(cluV1.getId(),versionDisplayInfo.getId());
2862 assertEquals(cluV1.getVersionInfo().getVersionIndId(),cluV2.getVersionInfo().getVersionIndId());
2863 assertEquals(cluV1.getVersionInfo().getVersionIndId(),cluV3.getVersionInfo().getVersionIndId());
2864 client.setCurrentCluVersion(cluV3.getId(), null);
2865 versionDisplayInfo = client.getCurrentVersion(LuServiceConstants.CLU_NAMESPACE_URI, cluV1.getVersionInfo().getVersionIndId());
2866 assertEquals(versionDisplayInfo.getId(),cluV3.getId());
2867
2868
2869 SearchRequest searchRequest = new SearchRequest();
2870 SearchParam param = new SearchParam();
2871 param.setKey("lu.queryParam.cluVersionIndId");
2872 param.setValue(versionDisplayInfo.getVersionIndId());
2873 searchRequest.getParams().add(param);
2874 searchRequest.setSearchKey("lu.search.clu.versions");
2875 SearchResult searchResult = client.search(searchRequest);
2876 assertEquals(3,searchResult.getRows().size());
2877
2878 }
2879
2880 private CluSetInfo createCluSetInfo() throws ParseException {
2881 CluSetInfo cluSetInfo = new CluSetInfo();
2882
2883 RichTextInfo desc = new RichTextInfo();
2884 desc.setFormatted("<p>Formatted Desc</p>");
2885 desc.setPlain("plain");
2886 cluSetInfo.setDescr(desc);
2887 cluSetInfo.setEffectiveDate(DF.parse("20080101"));
2888 cluSetInfo.setExpirationDate(DF.parse("20180101"));
2889 cluSetInfo.setName("Clu set name");
2890 cluSetInfo.setState ("draft");
2891 cluSetInfo.setType ("kuali.cluset.course");
2892 return cluSetInfo;
2893 }
2894
2895 private CluInfo createCluInfo() throws ParseException {
2896 CluInfo clu = new CluInfo();
2897
2898 CluAccountingInfo accountingInfo = new CluAccountingInfo();
2899 accountingInfo.getAttributes().put("AccountingAttrKey1",
2900 "AccountingAttrValue1");
2901 accountingInfo.getAttributes().put("AccountingAttrKey2",
2902 "AccountingAttrValue2");
2903 clu.setAccountingInfo(accountingInfo);
2904
2905 CluIdentifierInfo officialIdentifier = new CluIdentifierInfo();
2906 officialIdentifier.setCode("offId-code");
2907 officialIdentifier.setDivision("offId-division");
2908 officialIdentifier.setLevel("offId-level");
2909 officialIdentifier.setLongName("offId-longName");
2910 officialIdentifier.setShortName("offId-shortName");
2911 officialIdentifier.setState("offId-state");
2912 officialIdentifier.setType("offId-type");
2913 officialIdentifier.setVariation("offId-variation");
2914 officialIdentifier.setSuffixCode("offId-suffixcode");
2915 officialIdentifier.setOrgId("offId-orgid");
2916 clu.setOfficialIdentifier(officialIdentifier);
2917
2918 CluIdentifierInfo cluId1 = new CluIdentifierInfo();
2919 cluId1.setCode("cluId1-code");
2920 cluId1.setDivision("cluId1-division");
2921 cluId1.setLevel("cluId1-level");
2922 cluId1.setLongName("cluId1-longName");
2923 cluId1.setShortName("cluId1-shortName");
2924 cluId1.setState("cluId1-state");
2925 cluId1.setType("cluId1-type");
2926 cluId1.setVariation("cluId1-variation");
2927 cluId1.setSuffixCode("cluId1-suffixcode");
2928 cluId1.setOrgId("cluId1-orgid");
2929 clu.getAlternateIdentifiers().add(cluId1);
2930
2931 CluIdentifierInfo cluId2 = new CluIdentifierInfo();
2932 cluId2.setCode("cluId2-code");
2933 cluId2.setDivision("cluId2-division");
2934 cluId2.setLevel("cluId2-level");
2935 cluId2.setLongName("cluId2-longName");
2936 cluId2.setShortName("cluId2-shortName");
2937 cluId2.setState("cluId2-state");
2938 cluId2.setType("cluId2-type");
2939 cluId2.setVariation("cluId2-variation");
2940 cluId2.setSuffixCode("cluId2-suffixcode");
2941 cluId2.setOrgId("cluId2-orgid");
2942 clu.getAlternateIdentifiers().add(cluId2);
2943
2944 clu.getAttributes().put("cluAttrKey1", "cluAttrValue1");
2945 clu.getAttributes().put("cluAttrKey2", "cluAttrValue2");
2946
2947 clu.setCanCreateLui(true);
2948
2949 clu.setDefaultEnrollmentEstimate(545);
2950 clu.setDefaultMaximumEnrollment(999);
2951
2952 RichTextInfo desc = new RichTextInfo();
2953 desc.setFormatted("<p>DESC FORMATTED</p>");
2954 desc.setPlain("DESC PLAIN");
2955 clu.setDescr(desc);
2956
2957 clu.setEffectiveDate(DF.parse("20100203"));
2958 clu.setExpirationDate(DF.parse("21001231"));
2959
2960 clu.setEnrollable(true);
2961 clu.setHazardousForDisabledStudents(true);
2962
2963 AffiliatedOrgInfo aforg = new AffiliatedOrgInfo();
2964 aforg.setOrgId("AFF-ORG1");
2965 aforg.setPercentage(35l);
2966
2967 AffiliatedOrgInfo aforg1 = new AffiliatedOrgInfo();
2968 aforg1.setOrgId("AFF-ORG2");
2969 aforg1.setPercentage(65l);
2970
2971 List<AffiliatedOrgInfo> affiliatedOrgs = new ArrayList<AffiliatedOrgInfo>();
2972 affiliatedOrgs.add(aforg);
2973 affiliatedOrgs.add(aforg1);
2974
2975 CurrencyAmountInfo ca = new CurrencyAmountInfo();
2976 ca.setCurrencyQuantity(100);
2977 ca.setCurrencyTypeKey("DLLR");
2978
2979 CurrencyAmountInfo ca1 = new CurrencyAmountInfo();
2980 ca.setCurrencyQuantity(200);
2981 ca.setCurrencyTypeKey("DLLR");
2982
2983 List<CurrencyAmountInfo> caList = new ArrayList<CurrencyAmountInfo>();
2984 caList.add(ca);
2985
2986 List<CurrencyAmountInfo> caList1 = new ArrayList<CurrencyAmountInfo>();
2987 caList.add(ca);
2988 caList.add(ca1);
2989
2990 RichTextInfo cfRecDesc = new RichTextInfo();
2991 cfRecDesc.setPlain("Clu Fee Record");
2992
2993 CluFeeRecordInfo feeRec = new CluFeeRecordInfo();
2994 feeRec.setAffiliatedOrgs(affiliatedOrgs);
2995 feeRec.setFeeAmounts(caList);
2996 feeRec.setFeeType("FEE-TYPE-X");
2997 feeRec.setRateType("RATE-TYPE-X");
2998 feeRec.setDescr(cfRecDesc);
2999
3000 CluFeeRecordInfo feeRec1 = new CluFeeRecordInfo();
3001 feeRec1.setAffiliatedOrgs(affiliatedOrgs);
3002 feeRec1.setFeeAmounts(caList1);
3003 feeRec1.setFeeType("FEE-TYPE-Y");
3004 feeRec1.setRateType("RATE-TYPE-Y");
3005
3006 List<CluFeeRecordInfo> feeRecList = new ArrayList<CluFeeRecordInfo>();
3007 feeRecList.add(feeRec);
3008 feeRecList.add(feeRec1);
3009
3010 RichTextInfo cfDesc = new RichTextInfo();
3011 cfDesc.setPlain("Clu Fee");
3012
3013 CluFeeInfo feeInfo = new CluFeeInfo();
3014 feeInfo.getAttributes().put("FeeAttrKey1", "FeeAttrValue1");
3015 feeInfo.getAttributes().put("FeeAttrKey2", "FeeAttrValue2");
3016 feeInfo.setCluFeeRecords(feeRecList);
3017 feeInfo.setDescr(cfDesc);
3018 clu.setFeeInfo(feeInfo);
3019
3020 clu.setHasEarlyDropDeadline(true);
3021
3022 clu.setHazardousForDisabledStudents(true);
3023
3024 CluInstructorInfo primaryInstructor = new CluInstructorInfo();
3025 primaryInstructor.setOrgId("EXT-orgId-1");
3026 primaryInstructor.setPersonId("EXT-personId-1");
3027 primaryInstructor.getAttributes().put("PrimaryInstAttrKey1",
3028 "PrimaryInstAttrValue1");
3029 primaryInstructor.getAttributes().put("PrimaryInstAttrKey2",
3030 "PrimaryInstAttrValue2");
3031 clu.setPrimaryInstructor(primaryInstructor);
3032
3033 CluInstructorInfo instructor1 = new CluInstructorInfo();
3034 instructor1.setOrgId("EXT-orgId-2");
3035 instructor1.setPersonId("EXT-personId-2");
3036 instructor1.getAttributes().put("Inst1AttrKey1", "Inst1AttrValue1");
3037 instructor1.getAttributes().put("Inst1AttrKey2", "Inst1AttrValue2");
3038 clu.getInstructors().add(instructor1);
3039
3040 CluInstructorInfo instructor2 = new CluInstructorInfo();
3041 instructor2.setOrgId("EXT-orgId-3");
3042 instructor2.setPersonId("EXT-personId-3");
3043 instructor2.getAttributes().put("Inst2AttrKey1", "Inst2AttrValue1");
3044 instructor2.getAttributes().put("Inst2AttrKey2", "Inst2AttrValue2");
3045 clu.getInstructors().add(instructor2);
3046
3047 LuCodeInfo luCode1 = new LuCodeInfo();
3048 luCode1.setId("luCode1.key");
3049 luCode1.setDescr("luCode1-desc");
3050 luCode1.setValue("luCode1-value");
3051 luCode1.getAttributes().put("luCode1AttrKey1", "luCode1AttrValue1");
3052 luCode1.getAttributes().put("luCode1AttrKey2", "luCode1AttrValue2");
3053 luCode1.setType("kuali.someKindOfLuCode");
3054 clu.getLuCodes().add(luCode1);
3055
3056 LuCodeInfo luCode2 = new LuCodeInfo();
3057 luCode2.setId("luCode2.key");
3058 luCode2.setDescr("luCode2-desc");
3059 luCode2.setValue("luCode2-value");
3060 luCode2.getAttributes().put("luCode2AttrKey1", "luCode2AttrValue1");
3061 luCode2.getAttributes().put("luCode2AttrKey2", "luCode2AttrValue2");
3062 luCode2.setType("kuali.someKindOfLuCode");
3063 clu.getLuCodes().add(luCode2);
3064
3065 RichTextInfo marketingDesc = new RichTextInfo();
3066 marketingDesc.setFormatted("<p>marketingDesc FORMATTED</p>");
3067 marketingDesc.setPlain("marketingDesc PLAIN");
3068
3069 clu.setNextReviewPeriod("nextReviewPeriod");
3070
3071 clu.getOfferedAtpTypes().add("offeredAtpType1");
3072 clu.getOfferedAtpTypes().add("offeredAtpType2");
3073
3074
3075 CluInstructorInfo pubPrimaryInstructor = new CluInstructorInfo();
3076 pubPrimaryInstructor.setOrgId("EXT-orgId-234");
3077 pubPrimaryInstructor.setPersonId("EXT-personId-2451");
3078 pubPrimaryInstructor.getAttributes().put("PubPrimaryInstAttrKey1",
3079 "PubPrimaryInstAttrValue1");
3080 pubPrimaryInstructor.getAttributes().put("PubPrimaryInstAttrKey2",
3081 "PubPrimaryInstAttrValue2");
3082
3083 CluInstructorInfo pubInstructor1 = new CluInstructorInfo();
3084 pubInstructor1.setOrgId("EXT-orgId-2");
3085 pubInstructor1.setPersonId("EXT-personId-2");
3086 pubInstructor1.getAttributes().put("PubInst1AttrKey1",
3087 "PubInst1AttrValue1");
3088 pubInstructor1.getAttributes().put("PubInst1AttrKey2",
3089 "PubInst1AttrValue2");
3090
3091 CluInstructorInfo pubInstructor2 = new CluInstructorInfo();
3092 pubInstructor2.setOrgId("EXT-orgId-3");
3093 pubInstructor2.setPersonId("EXT-personId-3");
3094 pubInstructor2.getAttributes().put("PubInst2AttrKey1",
3095 "PubInst2AttrValue1");
3096 pubInstructor2.getAttributes().put("PubInst2AttrKey2",
3097 "PubInst2AttrValue2");
3098
3099 clu.setReferenceURL("http://student.kuali.org/clus");
3100
3101 clu.setState("Clu-state");
3102
3103 TimeAmountInfo stdDuration = new TimeAmountInfo();
3104 stdDuration.setAtpDurationTypeKey("EXT-stdDuration-Id1");
3105 stdDuration.setTimeQuantity(new Integer(7867));
3106 clu.setStdDuration(stdDuration);
3107
3108 clu.setType("kuali.SomeKindOfClu");
3109
3110 createCampusLocationList(clu);
3111
3112 createIntensity(clu);
3113
3114 createAccreditationList(clu);
3115
3116 createAdminOrgs(clu);
3117
3118 return clu;
3119 }
3120
3121 private void createAdminOrgs(CluInfo clu) {
3122 AdminOrgInfo adminOrg = new AdminOrgInfo();
3123 adminOrg.setOrgId("PRIMARY-ADMIN-ORG-ID");
3124 adminOrg.getAttributes().put("PrimaryAdminOrgAttrKey1",
3125 "PrimaryAdminOrgAttrValue1");
3126 adminOrg.getAttributes().put("PrimaryAdminOrgAttrKey2",
3127 "PrimaryAdminOrgAttrValue2");
3128 adminOrg.setType("kuali.altadminType1");
3129
3130 clu.getAdminOrgs().add(adminOrg);
3131 AdminOrgInfo altAdminOrg1 = new AdminOrgInfo();
3132 altAdminOrg1.setOrgId("ALT-ADMIN-ORG-ID1");
3133 altAdminOrg1.getAttributes().put("AltAdminOrg1AttrKey1",
3134 "AltAdminOrg1AttrValue1");
3135 altAdminOrg1.getAttributes().put("AltAdminOrg1AttrKey2",
3136 "AltAdminOrg1AttrValue2");
3137 altAdminOrg1.getAttributes().put("AltAdminOrg1AttrKey3",
3138 "AltAdminOrg1AttrValue3");
3139 altAdminOrg1.setType("kuali.altadminType1");
3140
3141 AdminOrgInfo altAdminOrg2 = new AdminOrgInfo();
3142 altAdminOrg2.setOrgId("ALT-ADMIN-ORG-ID2");
3143 altAdminOrg2.getAttributes().put("AltAdminOrg2AttrKey1",
3144 "AltAdminOrg2AttrValue1");
3145 altAdminOrg2.getAttributes().put("AltAdminOrg2AttrKey2",
3146 "AltAdminOrg2AttrValue2");
3147 altAdminOrg2.setType("kuali.altadminType1");
3148
3149 clu.getAdminOrgs().add(altAdminOrg1);
3150 clu.getAdminOrgs().add(altAdminOrg2);
3151
3152 }
3153
3154 private void checkAdminOrgsCreate(CluInfo clu) {
3155
3156 assertEquals("PRIMARY-ADMIN-ORG-ID", clu.getAdminOrgs().get(0)
3157 .getOrgId());
3158 assertEquals(2, clu.getAdminOrgs().get(0).getAttributes().size());
3159 assertEquals("PrimaryAdminOrgAttrValue1", clu.getAdminOrgs().get(0)
3160 .getAttributes().get("PrimaryAdminOrgAttrKey1"));
3161 assertEquals("PrimaryAdminOrgAttrValue2", clu.getAdminOrgs().get(0)
3162 .getAttributes().get("PrimaryAdminOrgAttrKey2"));
3163
3164 assertEquals("ALT-ADMIN-ORG-ID1", clu.getAdminOrgs().get(1)
3165 .getOrgId());
3166 assertEquals(3, clu.getAdminOrgs().get(1).getAttributes()
3167 .size());
3168 assertEquals("AltAdminOrg1AttrValue1", clu.getAdminOrgs().get(
3169 1).getAttributes().get("AltAdminOrg1AttrKey1"));
3170 assertEquals("AltAdminOrg1AttrValue2", clu.getAdminOrgs().get(
3171 1).getAttributes().get("AltAdminOrg1AttrKey2"));
3172 assertEquals("AltAdminOrg1AttrValue3", clu.getAdminOrgs().get(
3173 1).getAttributes().get("AltAdminOrg1AttrKey3"));
3174
3175 assertEquals("ALT-ADMIN-ORG-ID2", clu.getAdminOrgs().get(2)
3176 .getOrgId());
3177 assertEquals(2, clu.getAdminOrgs().get(2).getAttributes()
3178 .size());
3179 assertEquals("AltAdminOrg2AttrValue1", clu.getAdminOrgs().get(
3180 2).getAttributes().get("AltAdminOrg2AttrKey1"));
3181 assertEquals("AltAdminOrg2AttrValue2", clu.getAdminOrgs().get(
3182 2).getAttributes().get("AltAdminOrg2AttrKey2"));
3183 }
3184
3185 private void updateAdminOrgs(CluInfo clu) {
3186
3187 clu.getAdminOrgs().get(0).setOrgId("UPD-PRIMARY-ADMIN-ORG-ID");
3188 clu.getAdminOrgs().get(0).getAttributes().put("PrimaryAdminOrgAttrKey3",
3189 "PrimaryAdminOrgAttrValue3");
3190 clu.getAdminOrgs().get(0).getAttributes().remove(
3191 "PrimaryAdminOrgAttrKey2");
3192 clu.getAdminOrgs().get(0).getAttributes().put("PrimaryAdminOrgAttrKey4",
3193 "PrimaryAdminOrgAttrValue4");
3194
3195 AdminOrgInfo altAdminOrg3 = new AdminOrgInfo();
3196 altAdminOrg3.setOrgId("UPD-ADMIN-ORG-ID3");
3197 altAdminOrg3.getAttributes().put("UPDAdminOrg3AttrKey1",
3198 "UPDAdminOrg3AttrKey1");
3199 altAdminOrg3.getAttributes().put("UPDAdminOrg3AttrKey2",
3200 "UPDAdminOrg3AttrKey1");
3201 altAdminOrg3.setType("kuali.testType");
3202
3203 clu.getAdminOrgs().remove(1);
3204 clu.getAdminOrgs().add(altAdminOrg3);
3205 }
3206
3207 private void checkAdminOrgUpdate(CluInfo clu) {
3208
3209 assertEquals("UPD-PRIMARY-ADMIN-ORG-ID", clu.getAdminOrgs().get(0)
3210 .getOrgId());
3211 assertEquals(3, clu.getAdminOrgs().get(0).getAttributes().size());
3212 assertEquals("PrimaryAdminOrgAttrValue4", clu.getAdminOrgs().get(0)
3213 .getAttributes().get("PrimaryAdminOrgAttrKey4"));
3214 assertNull(clu.getAdminOrgs().get(0).getAttributes().get(
3215 "PrimaryAdminOrgAttrKey2"));
3216 assertEquals(3, clu.getAdminOrgs().size());
3217 assertEquals("UPD-PRIMARY-ADMIN-ORG-ID", clu.getAdminOrgs().get(0)
3218 .getOrgId());
3219 assertEquals(3, clu.getAdminOrgs().get(0).getAttributes()
3220 .size());
3221 assertEquals("PrimaryAdminOrgAttrValue1", clu.getAdminOrgs().get(
3222 0).getAttributes().get("PrimaryAdminOrgAttrKey1"));
3223 assertEquals("PrimaryAdminOrgAttrValue4", clu.getAdminOrgs().get(
3224 0).getAttributes().get("PrimaryAdminOrgAttrKey4"));
3225 assertEquals("PrimaryAdminOrgAttrValue3", clu.getAdminOrgs().get(
3226 0).getAttributes().get("PrimaryAdminOrgAttrKey3"));
3227 assertEquals("ALT-ADMIN-ORG-ID2", clu.getAdminOrgs().get(1)
3228 .getOrgId());
3229 assertEquals(2, clu.getAdminOrgs().get(1).getAttributes()
3230 .size());
3231 assertEquals("AltAdminOrg2AttrValue2", clu.getAdminOrgs().get(
3232 1).getAttributes().get("AltAdminOrg2AttrKey2"));
3233 assertEquals("AltAdminOrg2AttrValue1", clu.getAdminOrgs().get(
3234 1).getAttributes().get("AltAdminOrg2AttrKey1"));
3235 }
3236
3237 private void createAccreditationList(CluInfo clu) throws ParseException {
3238 AccreditationInfo accreditationOrg1 = new AccreditationInfo();
3239 accreditationOrg1.setOrgId("EXT-orgId-1");
3240 accreditationOrg1.setEffectiveDate(DF.parse("20100203"));
3241 accreditationOrg1.setExpirationDate(DF.parse("21001231"));
3242 accreditationOrg1.getAttributes().put("Accred1AttrKey1",
3243 "Accred1AttrValue1");
3244 accreditationOrg1.getAttributes().put("Accred1AttrKey2",
3245 "Accred1AttrValue2");
3246
3247 AccreditationInfo accreditationOrg2 = new AccreditationInfo();
3248 accreditationOrg2.setOrgId("EXT-orgId-2");
3249 accreditationOrg2.setEffectiveDate(DF.parse("20110203"));
3250 accreditationOrg2.setExpirationDate(DF.parse("21011231"));
3251 accreditationOrg2.getAttributes().put("Accred2AttrKey1",
3252 "Accred2AttrValue1");
3253 accreditationOrg2.getAttributes().put("Accred2AttrKey2",
3254 "Accred2AttrValue2");
3255
3256 clu.getAccreditations().add(accreditationOrg1);
3257 clu.getAccreditations().add(accreditationOrg2);
3258 }
3259
3260 private void checkAccreditationListCreate(CluInfo clu)
3261 throws ParseException {
3262
3263 assertEquals(2, clu.getAccreditations().size());
3264
3265 assertEquals("EXT-orgId-1", clu.getAccreditations().get(0)
3266 .getOrgId());
3267 assertEquals(DF.parse("20100203"), clu.getAccreditations().get(0)
3268 .getEffectiveDate());
3269 assertEquals(DF.parse("21001231"), clu.getAccreditations().get(0)
3270 .getExpirationDate());
3271 assertEquals(2, clu.getAccreditations().get(0).getAttributes()
3272 .size());
3273 assertEquals("Accred1AttrValue1", clu.getAccreditations().get(0)
3274 .getAttributes().get("Accred1AttrKey1"));
3275 assertEquals("Accred1AttrValue2", clu.getAccreditations().get(0)
3276 .getAttributes().get("Accred1AttrKey2"));
3277
3278 assertEquals("EXT-orgId-2", clu.getAccreditations().get(1)
3279 .getOrgId());
3280 assertEquals(DF.parse("20110203"), clu.getAccreditations().get(1)
3281 .getEffectiveDate());
3282 assertEquals(DF.parse("21011231"), clu.getAccreditations().get(1)
3283 .getExpirationDate());
3284 assertEquals(2, clu.getAccreditations().get(1).getAttributes()
3285 .size());
3286 assertEquals("Accred2AttrValue1", clu.getAccreditations().get(1)
3287 .getAttributes().get("Accred2AttrKey1"));
3288 assertEquals("Accred2AttrValue2", clu.getAccreditations().get(1)
3289 .getAttributes().get("Accred2AttrKey2"));
3290 }
3291
3292 private void updateAccreditationList(CluInfo clu) throws ParseException {
3293
3294 AccreditationInfo accreditationOrg3 = new AccreditationInfo();
3295 accreditationOrg3.setOrgId("EXT-orgId-3");
3296 accreditationOrg3.setEffectiveDate(DF.parse("20120203"));
3297 accreditationOrg3.setExpirationDate(DF.parse("21021231"));
3298
3299 AccreditationInfo accreditationOrg4 = new AccreditationInfo();
3300 accreditationOrg4.setOrgId("EXT-orgId-4");
3301 accreditationOrg4.setEffectiveDate(DF.parse("20130203"));
3302 accreditationOrg4.setExpirationDate(DF.parse("21031231"));
3303 accreditationOrg4.getAttributes().put("Accred4AttrKey1",
3304 "Accred4AttrValue1");
3305
3306 clu.getAccreditations().add(accreditationOrg3);
3307 clu.getAccreditations().add(accreditationOrg4);
3308
3309 clu.getAccreditations().get(0).getAttributes().remove(
3310 "Accred1AttrKey2");
3311 clu.getAccreditations().get(0).getAttributes().put(
3312 "Accred1AttrKey1", "Accred1AttrValue1-UPD");
3313 clu.getAccreditations().remove(1);
3314 }
3315
3316 private void checkAccreditationListUpdate(CluInfo clu)
3317 throws ParseException {
3318
3319 assertEquals(3, clu.getAccreditations().size());
3320
3321 assertEquals("EXT-orgId-1", clu.getAccreditations().get(0)
3322 .getOrgId());
3323 assertEquals(1, clu.getAccreditations().get(0).getAttributes()
3324 .size());
3325 assertEquals("Accred1AttrValue1-UPD", clu.getAccreditations().get(0)
3326 .getAttributes().get("Accred1AttrKey1"));
3327
3328 assertEquals("EXT-orgId-3", clu.getAccreditations().get(1)
3329 .getOrgId());
3330 assertEquals(DF.parse("20120203"), clu.getAccreditations().get(1)
3331 .getEffectiveDate());
3332 assertEquals(DF.parse("21021231"), clu.getAccreditations().get(1)
3333 .getExpirationDate());
3334 assertEquals(0, clu.getAccreditations().get(1).getAttributes()
3335 .size());
3336
3337 assertEquals("EXT-orgId-4", clu.getAccreditations().get(2)
3338 .getOrgId());
3339 assertEquals(DF.parse("20130203"), clu.getAccreditations().get(2)
3340 .getEffectiveDate());
3341 assertEquals(DF.parse("21031231"), clu.getAccreditations().get(2)
3342 .getExpirationDate());
3343 assertEquals(1, clu.getAccreditations().get(2).getAttributes()
3344 .size());
3345 assertEquals("Accred4AttrValue1", clu.getAccreditations().get(2)
3346 .getAttributes().get("Accred4AttrKey1"));
3347
3348 }
3349
3350 private void createIntensity(CluInfo clu) {
3351 AmountInfo intensity = new AmountInfo();
3352 intensity.setUnitType("EXT-intensity-Id1");
3353 intensity.setUnitQuantity("123");
3354 clu.setIntensity(intensity);
3355 }
3356
3357 private void checkIntensityCreate(CluInfo clu) {
3358 assertEquals("EXT-intensity-Id1", clu.getIntensity()
3359 .getUnitType());
3360 assertEquals("123", clu.getIntensity().getUnitQuantity());
3361 }
3362
3363 private void updateIntensity(CluInfo clu) {
3364 clu.getIntensity().setUnitType("UPD-intensity-Id1");
3365 clu.getIntensity().setUnitQuantity("456");
3366 }
3367
3368 private void checkIntensityUpdate(CluInfo clu) {
3369 assertEquals("UPD-intensity-Id1", clu.getIntensity()
3370 .getUnitType());
3371 assertEquals("456", clu.getIntensity().getUnitQuantity());
3372
3373 }
3374
3375 private void createCampusLocationList(CluInfo clu) {
3376 clu.getCampusLocations().add("EXT-Campus-Location-1");
3377 clu.getCampusLocations().add("EXT-Campus-Location-2");
3378 }
3379
3380 private void checkCampusLocationCreate(CluInfo clu) {
3381 assertEquals(2, clu.getCampusLocations().size());
3382 assertEquals("EXT-Campus-Location-1", clu.getCampusLocations()
3383 .get(0));
3384 assertEquals("EXT-Campus-Location-2", clu.getCampusLocations()
3385 .get(1));
3386 }
3387
3388 private void updateCampusLocationList(CluInfo clu) {
3389 clu.getCampusLocations().add("EXT-Campus-Location-3");
3390 clu.getCampusLocations().add("EXT-Campus-Location-4");
3391 clu.getCampusLocations().remove(0);
3392 }
3393
3394 private void checkCampusLocationUpdate(CluInfo clu) {
3395 assertEquals(3, clu.getCampusLocations().size());
3396 assertEquals("EXT-Campus-Location-2", clu.getCampusLocations()
3397 .get(0));
3398 assertEquals("EXT-Campus-Location-3", clu.getCampusLocations()
3399 .get(1));
3400 assertEquals("EXT-Campus-Location-4", clu.getCampusLocations()
3401 .get(2));
3402 }
3403
3404 @Test
3405 public void testSearchForCluInCluSets() throws Exception {
3406 SearchRequest searchRequest = new SearchRequest();
3407 searchRequest.setSearchKey("cluset.search.generic");
3408
3409 List<SearchParam> queryParamValues = new ArrayList<SearchParam>();
3410 SearchParam searchParam = new SearchParam();
3411 searchParam.setKey("cluset.queryParam.luOptionalId");
3412 searchParam.setValue("CLU-5");
3413 queryParamValues.add(searchParam);
3414
3415 searchRequest.setParams(queryParamValues);
3416 SearchResult cluSets = client.search(searchRequest);
3417
3418 Assert.assertEquals(2, cluSets.getRows().size());
3419 }
3420
3421 @Test
3422 public void testSearchForCluInCluSets_EmptyResult() throws Exception {
3423 SearchRequest searchRequest = new SearchRequest();
3424 searchRequest.setSearchKey("cluset.search.generic");
3425
3426 List<SearchParam> queryParamValues = new ArrayList<SearchParam>();
3427 SearchParam searchParam = new SearchParam();
3428 searchParam.setKey("lu.queryParam.luOptionalId");
3429 searchParam.setValue("XXX");
3430 queryParamValues.add(searchParam);
3431
3432 searchRequest.setParams(queryParamValues);
3433 SearchResult cluSets = client.search(searchRequest);
3434
3435 Assert.assertEquals(0, cluSets.getRows().size());
3436 }
3437
3438 @Test
3439 public void testSearchForCluInCluRelations() throws Exception {
3440 SearchRequest searchRequest = new SearchRequest();
3441 searchRequest.setSearchKey("lu.search.cluCluRelation");
3442
3443 List<SearchParam> queryParamValues = new ArrayList<SearchParam>();
3444 SearchParam searchParam = new SearchParam();
3445 searchParam.setKey("lu.queryParam.luOptionalId");
3446 searchParam.setValue("CLU-1");
3447 queryParamValues.add(searchParam);
3448
3449 searchRequest.setParams(queryParamValues);
3450 SearchResult clus = client.search(searchRequest);
3451
3452 Assert.assertEquals(2, clus.getRows().size());
3453 }
3454
3455 @Test
3456 public void testSearchForCluInCluRelations_EmptyResult() throws Exception {
3457 SearchRequest searchRequest = new SearchRequest();
3458 searchRequest.setSearchKey("lu.search.cluCluRelation");
3459
3460 List<SearchParam> queryParamValues = new ArrayList<SearchParam>();
3461 SearchParam searchParam = new SearchParam();
3462 searchParam.setKey("lu.queryParam.luOptionalId");
3463 searchParam.setValue("XXX");
3464 queryParamValues.add(searchParam);
3465
3466 searchRequest.setParams(queryParamValues);
3467 SearchResult clus = client.search(searchRequest);
3468
3469 Assert.assertEquals(0, clus.getRows().size());
3470 }
3471
3472 @Test
3473 public void testCluPublicationCrud() throws ParseException, AlreadyExistsException, DataValidationErrorException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, DoesNotExistException, VersionMismatchException{
3474
3475 FieldInfo variant;
3476
3477 CluPublicationInfo cluPublication1 = new CluPublicationInfo();
3478 cluPublication1.setEffectiveDate(DF.parse("20120203"));
3479 cluPublication1.setExpirationDate(DF.parse("20130203"));
3480 cluPublication1.setStartCycle("StartCycle1");
3481 cluPublication1.setEndCycle("EndCycle1");
3482 cluPublication1.setState("clupubState1");
3483 cluPublication1.setType("cluPublication.Test.Type.1");
3484 cluPublication1.setCluId("CLU-1");
3485 variant = new FieldInfo();
3486 variant.setId("field1.one");
3487 variant.setValue("value1.one");
3488 cluPublication1.getVariants().add(variant);
3489 variant = new FieldInfo();
3490 variant.setId("field1.two");
3491 variant.setValue("value1.two");
3492 cluPublication1.getVariants().add(variant);
3493
3494 CluPublicationInfo cluPublication2 = new CluPublicationInfo();
3495 cluPublication2.setEffectiveDate(DF.parse("20120203"));
3496 cluPublication2.setExpirationDate(DF.parse("20130203"));
3497 cluPublication2.setStartCycle("StartCycle2");
3498 cluPublication2.setEndCycle("EndCycle2");
3499 cluPublication2.setState("clupubState2");
3500 cluPublication2.setType("cluPublication.Test.Type.1");
3501 cluPublication2.setCluId("CLU-2");
3502 variant = new FieldInfo();
3503 variant.setId("field2.one");
3504 variant.setValue("value2.one");
3505 cluPublication2.getVariants().add(variant);
3506 variant = new FieldInfo();
3507 variant.setId("field2.two");
3508 variant.setValue("value2.two");
3509 cluPublication2.getVariants().add(variant);
3510
3511 CluPublicationInfo cluPublication3 = new CluPublicationInfo();
3512 cluPublication3.setEffectiveDate(DF.parse("20120203"));
3513 cluPublication3.setExpirationDate(DF.parse("20130203"));
3514 cluPublication3.setStartCycle("StartCycle3");
3515 cluPublication3.setEndCycle("EndCycle3");
3516 cluPublication3.setState("clupubState3");
3517 cluPublication3.setType("cluPublication.Test.Type.2");
3518 cluPublication3.setCluId("CLU-2");
3519 variant = new FieldInfo();
3520 variant.setId("field3.one");
3521 variant.setValue("value3.one");
3522 cluPublication3.getVariants().add(variant);
3523 variant = new FieldInfo();
3524 variant.setId("field3.two");
3525 variant.setValue("value3.two");
3526 cluPublication3.getVariants().add(variant);
3527
3528
3529 CluPublicationInfo createdCluPub1 = client.createCluPublication(cluPublication1.getCluId(), cluPublication1.getType(), cluPublication1);
3530 CluPublicationInfo createdCluPub2 = client.createCluPublication(cluPublication2.getCluId(), cluPublication2.getType(), cluPublication2);
3531 CluPublicationInfo createdCluPub3 = client.createCluPublication(cluPublication3.getCluId(), cluPublication3.getType(), cluPublication3);
3532
3533
3534 assertNotNull(createdCluPub1.getId());
3535 assertEquals(cluPublication1.getEffectiveDate(),createdCluPub1.getEffectiveDate());
3536 assertEquals(cluPublication1.getExpirationDate(),createdCluPub1.getExpirationDate());
3537 assertEquals(cluPublication1.getStartCycle(),createdCluPub1.getStartCycle());
3538 assertEquals(cluPublication1.getEndCycle(),createdCluPub1.getEndCycle());
3539 assertEquals(cluPublication1.getState(),createdCluPub1.getState());
3540 assertEquals(cluPublication1.getType(),createdCluPub1.getType());
3541 assertEquals(cluPublication1.getCluId(),createdCluPub1.getCluId());
3542 assertNotNull(createdCluPub3);
3543
3544
3545 CluPublicationInfo gotCluPub1 = client.getCluPublication(createdCluPub1.getId());
3546 assertEquals(createdCluPub1.getId(),gotCluPub1.getId());
3547
3548 List<CluPublicationInfo> gotCluPubsByType = client.getCluPublicationsByType("cluPublication.Test.Type.1");
3549 assertEquals(2,gotCluPubsByType.size());
3550
3551 List<CluPublicationInfo> gotCluPubsByClu = client.getCluPublicationsByCluId("CLU-2");
3552 assertEquals(2,gotCluPubsByClu.size());
3553
3554
3555 createdCluPub2.setEffectiveDate(DF.parse("20020203"));
3556 createdCluPub2.setExpirationDate(DF.parse("20030203"));
3557 createdCluPub2.setStartCycle("StartCycle2U");
3558 createdCluPub2.setEndCycle("EndCycle2U");
3559 createdCluPub2.setState("clupubState2U");
3560 createdCluPub2.setType("cluPublication.Test.Type.2");
3561 createdCluPub2.setCluId("CLU-1");
3562 createdCluPub2.getVariants().clear();
3563 variant = new FieldInfo();
3564 variant.setId("field2.oneU");
3565 variant.setValue("value2.oneU");
3566 createdCluPub2.getVariants().add(variant);
3567 variant = new FieldInfo();
3568 variant.setId("field2.twoU");
3569 variant.setValue("value2.twoU");
3570 createdCluPub2.getVariants().add(variant);
3571
3572 CluPublicationInfo updated = client.updateCluPublication(createdCluPub2.getId(), createdCluPub2);
3573
3574 try{
3575 client.updateCluPublication(createdCluPub2.getId(), createdCluPub2);
3576 assertTrue(false);
3577 }catch( VersionMismatchException e){
3578 assertTrue(true);
3579 }
3580
3581
3582
3583 assertEquals(createdCluPub2.getId(),updated.getId());
3584 assertEquals(createdCluPub2.getEffectiveDate(),updated.getEffectiveDate());
3585 assertEquals(createdCluPub2.getExpirationDate(),updated.getExpirationDate());
3586 assertEquals(createdCluPub2.getStartCycle(),updated.getStartCycle());
3587 assertEquals(createdCluPub2.getEndCycle(),updated.getEndCycle());
3588 assertEquals(createdCluPub2.getState(),updated.getState());
3589 assertEquals(createdCluPub2.getType(),updated.getType());
3590 assertEquals(createdCluPub2.getCluId(),updated.getCluId());
3591
3592 assertEquals(2,updated.getVariants().size());
3593 assertTrue(("field2.oneU".equals(updated.getVariants().get(0).getId())
3594 &&"value2.oneU".equals(updated.getVariants().get(0).getValue()))
3595 ||
3596 ("field2.twoU".equals(updated.getVariants().get(0).getId())
3597 &&"value2.twoU".equals(updated.getVariants().get(0).getValue())));
3598 }
3599 }