1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.kim.test.service;
17
18 import org.junit.Test;
19 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
20 import org.kuali.rice.kim.api.identity.Person;
21 import org.kuali.rice.kim.api.identity.principal.Principal;
22 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
23 import org.kuali.rice.kim.impl.identity.PersonImpl;
24 import org.kuali.rice.kim.impl.identity.PersonServiceImpl;
25 import org.kuali.rice.kim.impl.identity.external.EntityExternalIdentifierBo;
26 import org.kuali.rice.kim.test.KIMTestCase;
27 import org.kuali.rice.krad.bo.BusinessObject;
28 import org.kuali.rice.krad.data.KradDataServiceLocator;
29 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
30 import org.kuali.rice.test.BaselineTestCase;
31 import org.springframework.util.AutoPopulatingList;
32
33 import javax.xml.namespace.QName;
34
35 import java.util.HashMap;
36 import java.util.List;
37 import java.util.Map;
38
39 import static org.junit.Assert.*;
40
41
42
43
44
45
46
47 @BaselineTestCase.BaselineMode(BaselineTestCase.Mode.NONE)
48 public class PersonServiceImplTest extends KIMTestCase {
49
50 private PersonServiceImpl personService;
51
52 public void setUp() throws Exception {
53 super.setUp();
54 personService = GlobalResourceLoader.getService(new QName("personService"));
55
56 }
57
58
59
60
61 @Test
62 public void testGetPersonByExternalIdentifier() {
63
64 Principal principal = KimApiServiceLocator.getIdentityService().getPrincipal("p1");
65
66 EntityExternalIdentifierBo externalIdentifier = new EntityExternalIdentifierBo();
67 externalIdentifier.setId("externalIdentifierId");
68 externalIdentifier.setEntityId(principal.getEntityId());
69 externalIdentifier.setExternalId("000-00-0000");
70 externalIdentifier.setExternalIdentifierTypeCode("SSN");
71 KradDataServiceLocator.getDataObjectService().save(externalIdentifier);
72
73 List<Person> people = personService.getPersonByExternalIdentifier( "SSN", "000-00-0000" );
74 assertNotNull( "result object must not be null", people );
75 assertEquals( "exactly one record should be returned", 1, people.size() );
76 assertEquals( "the returned principal is not correct", "p1", people.get(0).getPrincipalId() );
77 }
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105 @Test
106 public void testGetPerson() {
107 Person p = personService.getPerson( "KULUSER" );
108 assertNotNull( "person object must not be null", p );
109 assertEquals( "class must match implementation class defined on service", personService.getPersonImplementationClass(), p.getClass() );
110 assertEquals( "person name does not match", "KULUSER", p.getFirstNameUnmasked() );
111 assertEquals( "principal name does not match", "kuluser", p.getPrincipalName() );
112 assertEquals( "KULUSER should have no address record", "", p.getAddressLine1Unmasked() );
113 assertEquals( "KULUSER should have no campus code", "", p.getCampusCode() );
114 assertEquals( "KULUSER should have no email address", "", p.getEmailAddressUnmasked() );
115 assertNotNull( "entity ID should be set", p.getEntityId() );
116 assertNotNull( "principal ID should be set", p.getPrincipalId() );
117
118
119 Person p1Person = personService.getPerson( "p1" );
120 assertNotNull( "person object must not be null", p );
121 assertEquals("employee ID does not match", "p1emplId", p1Person.getEmployeeId());
122 }
123
124 @Test
125 public void testGetPersonInactive() {
126 Person p = personService.getPerson( "inactiveuserid" );
127 assertNotNull( "person object must not be null", p );
128 assertEquals("principal ID does not match", "inactiveusernm", p.getPrincipalName());
129
130 }
131
132 @Test
133 public void testGetPersonByPrincipalName() {
134 Person p = personService.getPersonByPrincipalName( "kuluser" );
135 assertNotNull( "person object must not be null", p );
136 assertEquals( "person name does not match", "KULUSER", p.getFirstName() );
137 assertEquals( "principal id does not match", "KULUSER", p.getPrincipalId() );
138 }
139
140 @Test
141 public void testGetPersonByPrincipalNameInactive() {
142 Person p = personService.getPersonByPrincipalName( "inactiveusernm" );
143 assertEquals("principal ID does not match", "inactiveuserid", p.getPrincipalId());
144 }
145
146 @Test
147 public void testGetPersonByEmployeeIdNoInfo() {
148 Person p = personService.getPersonByEmployeeId( "" );
149 assertNull( "person object will be null", p );
150 }
151
152 @Test
153 public void testGetPersonByEmployeeIdNotFound() {
154 Person p = personService.getPersonByEmployeeId( "NotFound" );
155 assertNull( "person object will be null", p );
156 }
157
158 @Test
159 public void testGetPersonByEmployeeIdActive() {
160 Person p = personService.getPersonByEmployeeId( "0000001138" );
161 assertNotNull( "person object must not be null", p );
162 assertEquals( "person name does not match", "activeUserFirst", p.getFirstName() );
163 assertEquals( "principal id does not match", "activeuserid", p.getPrincipalId() );
164 }
165
166 @Test
167 public void testGetPersonByEmployeeIdInactiveUser() {
168 Person p = personService.getPersonByEmployeeId( "0000001139" );
169 assertNotNull( "person object must not be null", p );
170 assertEquals( "person name does not match", "InactiveUserFirst", p.getFirstName() );
171 assertEquals( "principal id does not match", "inactiveuserid", p.getPrincipalId() );
172 }
173
174 @Test
175 public void testGetPersonByEmployeeIdInactiveEmp() {
176 Person p = personService.getPersonByEmployeeId( "0000001140" );
177 assertNotNull( "person object must not be null", p );
178 assertEquals( "person name does not match", "InactiveEmplFirst", p.getFirstName() );
179 assertEquals( "principal id does not match", "inactiveempid", p.getPrincipalId() );
180 }
181
182 @Test
183 public void testConvertPersonPropertiesToEntityProperties() {
184 HashMap<String,String> criteria = new HashMap<String,String>();
185 criteria.put( "firstName", "System User" );
186 Map<String,String> entityCriteria = personService.convertPersonPropertiesToEntityProperties( criteria );
187 assertEquals( "number of criteria is not correct", 5, entityCriteria.size() );
188 assertNotNull( "criteria must filter for active entity types", entityCriteria.get( "entityTypeContactInfos.active" ) );
189 assertNotNull( "criteria must filter on entity type code", entityCriteria.get( "entityTypeContactInfos.entityTypeCode" ) );
190 assertNotNull( "criteria must filter for first name", entityCriteria.get( "names.firstName" ) );
191 assertNotNull( "criteria must filter for active names", entityCriteria.get( "names.active" ) );
192 assertNotNull( "criteria must filter for the default name", entityCriteria.get( "names.defaultValue" ) );
193 }
194
195
196
197
198 @Test
199 public void testFindPeople() {
200 HashMap<String,String> criteria = new HashMap<String,String>();
201 criteria.put( "firstName", "KULUSER" );
202 List<Person> people = personService.findPeople( criteria );
203 assertNotNull( "result must not be null", people );
204 assertEquals( "wrong number of people returned", 1, people.size() );
205 Person p = people.get( 0 );
206 assertEquals( "name must match criteria", "KULUSER", p.getFirstName() );
207 assertEquals( "principal name must be kuluser", "kuluser", p.getPrincipalName() );
208 }
209
210 @Test
211 public void testFindPeopleInactive() {
212 HashMap<String,String> criteria = new HashMap<String,String>();
213 criteria.put( "principals.active", "N" );
214 List<Person> people = personService.findPeople( criteria );
215 assertNotNull( "result must not be null", people );
216 assertEquals( "wrong number of people returned", 1, people.size() );
217 }
218
219 @Test
220 public void testFindPeopleBothInactiveAndActive() {
221 HashMap<String,String> criteria = new HashMap<String,String>();
222 criteria.put( "firstName", "InactiveUserFirst" );
223 List<Person> people = personService.findPeople( criteria );
224 assertNotNull( "result must not be null", people );
225 assertEquals( "wrong number of people returned", 1, people.size() );
226 }
227
228 @Test
229 public void testFindPeopleByWildcard() {
230 HashMap<String,String> criteria = new HashMap<String,String>();
231 criteria.put( "principalName", "!quick*" );
232 List<Person> people = personService.findPeople( criteria );
233 assertNotNull( "result must not be null", people );
234 assertEquals( "wrong number of people returned", 53, people.size() );
235 for (Person p: people) {
236 if (p.getPrincipalName().startsWith("quick")) {
237 fail("Invalid wildcard search results");
238 }
239 }
240 }
241
242 @Test
243 public void testResolvePrincipalNamesToPrincipalIds() throws Exception {
244
245 KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().addConfigFileLocation("KR-KIM", "classpath:org/kuali/rice/kim/bo/datadictionary/test/SampleBO.xml" );
246 KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().parseDataDictionaryConfigurationFiles( false );
247
248 Map<String,String> criteria = new HashMap<String,String>();
249 criteria.put( "anAttribute", "aValue" );
250 criteria.put( "anotherAttribute", "anotherValue" );
251 criteria.put( "personAttribute.principalName", "kuluser" );
252 System.out.println( "Before: " + criteria );
253 Map<String,String> newCritiera = personService.resolvePrincipalNamesToPrincipalIds( new SampleBO(), criteria );
254 assertNotNull( "returned map must not be null", newCritiera );
255 System.out.println( "After: " + newCritiera );
256 assertTrue( "new criteria must have a personPrincipalId entry", newCritiera.containsKey( "personPrincipalId" ) );
257 assertEquals( "resulting principal ID is not that expected", "KULUSER", newCritiera.get( "personPrincipalId" ) );
258 assertFalse( "new criteria must not contain the original PrincipalName entry", newCritiera.containsKey( "personAttribute.principalName" ) );
259
260
261 criteria.put( "personPrincipalId", "NOT KULUSER" );
262 System.out.println( "Before: " + criteria );
263 newCritiera = personService.resolvePrincipalNamesToPrincipalIds( new SampleBO(), criteria );
264 assertNotNull( "returned map must not be null", newCritiera );
265 System.out.println( "After: " + newCritiera );
266 assertTrue( "new criteria must have a personPrincipalId entry", newCritiera.containsKey( "personPrincipalId" ) );
267 assertEquals( "resulting principal ID should have been changed", "KULUSER", newCritiera.get( "personPrincipalId" ) );
268 }
269
270 @Test
271 public void testResolvePrincipalNamesToPrincipalIds_Nested() throws Exception {
272
273 KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().addConfigFileLocation( "", "classpath:org/kuali/rice/kim/bo/datadictionary/test/SampleBO.xml" );
274 KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary().parseDataDictionaryConfigurationFiles( false );
275
276 Map<String,String> criteria = new HashMap<String,String>();
277 criteria.put( "add.childBos.childsPersonAttribute.principalName", "kuluser" );
278 System.out.println( "Before: " + criteria );
279 Map<String,String> newCritiera = personService.resolvePrincipalNamesToPrincipalIds( new SampleBO(), criteria );
280 assertNotNull( "returned map must not be null", newCritiera );
281 System.out.println( "After: " + newCritiera );
282
283 assertTrue( "new criteria must have a childsPersonPrincipalId entry", newCritiera.containsKey( "add.childBos.childsPersonPrincipalId" ) );
284 assertFalse( "new criteria must not contain the original PrincipalName entry", newCritiera.containsKey( "add.childBos.childsPersonAttribute.principalName" ) );
285 }
286
287 @Test
288 public void testUpdateWhenNecessary() {
289 SampleBO bo = new SampleBO();
290 bo.setPersonPrincipalId( "KULUSER" );
291 Person p = bo.getPersonAttribute();
292 assertNotNull( "person object must not be null", p );
293 assertEquals( "principal IDs do not match", bo.getPersonPrincipalId(), p.getPrincipalId() );
294 assertSame( "second retrieval must return same object since ID not changed", p, bo.getPersonAttribute() );
295 }
296
297 @Test
298 public void testUpdatePersonIfNecessary() throws Exception {
299 Person person = personService.updatePersonIfNecessary("p1", null);
300 assertNotNull("person object must not be null", person);
301 assertEquals("principalId does not match", "p1", person.getPrincipalId() );
302 assertEquals("principalName does not match", "principal1", person.getPrincipalName());
303 }
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325 public static class SampleBO implements BusinessObject {
326 private String anAttribute;
327 private String anotherAttribute;
328 private String personPrincipalId;
329 private PersonImpl personAttribute;
330 private List<SampleChildBOWithPerson> childBos = new AutoPopulatingList(SampleChildBOWithPerson.class);
331 public String getAnAttribute() {
332 return this.anAttribute;
333 }
334 public void setAnAttribute(String anAttribute) {
335 this.anAttribute = anAttribute;
336 }
337 public String getAnotherAttribute() {
338 return this.anotherAttribute;
339 }
340 public void setAnotherAttribute(String anotherAttribute) {
341 this.anotherAttribute = anotherAttribute;
342 }
343 public String getPersonPrincipalId() {
344 return this.personPrincipalId;
345 }
346 public void setPersonPrincipalId(String personPrincipalId) {
347 this.personPrincipalId = personPrincipalId;
348 }
349 public PersonImpl getPersonAttribute() {
350 personAttribute = (PersonImpl) KimApiServiceLocator.getPersonService().updatePersonIfNecessary( personPrincipalId, personAttribute );
351 return personAttribute;
352 }
353 public void setPersonAttribute(PersonImpl personAttribute) {
354 this.personAttribute = personAttribute;
355 }
356 public void refresh() {}
357 public List<SampleChildBOWithPerson> getChildBos() {
358 return this.childBos;
359 }
360 public void setChildBos(List<SampleChildBOWithPerson> childBos) {
361 this.childBos = childBos;
362 }
363 }
364
365 public static class SampleChildBOWithPerson implements BusinessObject {
366
367 private String childsAttribute;
368 private String childsPersonPrincipalId;
369 private PersonImpl childsPersonAttribute;
370
371
372
373 public String getChildsAttribute() {
374 return this.childsAttribute;
375 }
376 public void setChildsAttribute(String childsAttribute) {
377 this.childsAttribute = childsAttribute;
378 }
379 public String getChildsPersonPrincipalId() {
380 return this.childsPersonPrincipalId;
381 }
382 public void setChildsPersonPrincipalId(String childsPersonPrincipalId) {
383 this.childsPersonPrincipalId = childsPersonPrincipalId;
384 }
385 public PersonImpl getChildsPersonAttribute() {
386 childsPersonAttribute = (PersonImpl) KimApiServiceLocator.getPersonService().updatePersonIfNecessary( childsPersonPrincipalId, childsPersonAttribute );
387 return childsPersonAttribute;
388 }
389 public void setChildsPersonAttribute(PersonImpl childsPersonAttribute) {
390 this.childsPersonAttribute = childsPersonAttribute;
391 }
392 public void refresh() {}
393 }
394 }