diff --git a/src/main/java/edu/hawaii/its/api/controller/GroupingsRestControllerv2_1.java b/src/main/java/edu/hawaii/its/api/controller/GroupingsRestControllerv2_1.java index f86ba2620..e55a1c0fa 100644 --- a/src/main/java/edu/hawaii/its/api/controller/GroupingsRestControllerv2_1.java +++ b/src/main/java/edu/hawaii/its/api/controller/GroupingsRestControllerv2_1.java @@ -46,7 +46,6 @@ import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestHeader; import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.RestController; diff --git a/src/main/java/edu/hawaii/its/api/exception/PasswordFoundAnalyzer.java b/src/main/java/edu/hawaii/its/api/exception/PasswordFoundAnalyzer.java index 2fde70d81..bf633495e 100644 --- a/src/main/java/edu/hawaii/its/api/exception/PasswordFoundAnalyzer.java +++ b/src/main/java/edu/hawaii/its/api/exception/PasswordFoundAnalyzer.java @@ -7,7 +7,8 @@ @Component public class PasswordFoundAnalyzer extends AbstractFailureAnalyzer { - @Override protected FailureAnalysis analyze(Throwable rootFailure, PasswordFoundException cause) { + @Override + protected FailureAnalysis analyze(Throwable rootFailure, PasswordFoundException cause) { String description = "A password(s) was found."; String action = "Delete the password(s) in the following location(s):" diff --git a/src/main/java/edu/hawaii/its/api/service/GroupingAssignmentService.java b/src/main/java/edu/hawaii/its/api/service/GroupingAssignmentService.java index 26cc3d54b..0aa2d852b 100644 --- a/src/main/java/edu/hawaii/its/api/service/GroupingAssignmentService.java +++ b/src/main/java/edu/hawaii/its/api/service/GroupingAssignmentService.java @@ -49,22 +49,26 @@ public class GroupingAssignmentService { @Autowired private GroupingsService groupingsService; - //returns an adminLists object containing the list of all admins and all groupings - public AdminListsHolder adminsGroupings(String adminUsername) { - logger.info(String.format("adminsGroupings; adminUsername: %s;", adminUsername)); - if (!memberService.isAdmin(adminUsername)) { + + /** + * returns an adminLists object containing the list of all admins and all groupings + */ + public AdminListsHolder adminsGroupings(String adminUhIdentifier) { + logger.info(String.format("adminsGroupings; adminUhIdentifier: %s;", adminUhIdentifier)); + if (!memberService.isAdmin(adminUhIdentifier)) { throw new AccessDeniedException(); } AdminListsHolder adminListsHolder = new AdminListsHolder(); - List adminGrouping = Arrays.asList(GROUPING_ADMINS); - Group admin = getMembers(adminUsername, adminGrouping).get(GROUPING_ADMINS); + Group admin = getMembers(adminUhIdentifier, adminGrouping).get(GROUPING_ADMINS); adminListsHolder.setAllGroupingPaths(groupingsService.allGroupingPaths()); adminListsHolder.setAdminGroup(admin); return adminListsHolder; } - //returns a group from grouper or the database + /** + * returns a group from grouper or the database + */ public Map getMembers(String ownerUsername, List groupPaths) { GetMembersResults getMembersResults = grouperApiService.getMembersResults( diff --git a/src/main/java/edu/hawaii/its/api/service/UpdateMemberService.java b/src/main/java/edu/hawaii/its/api/service/UpdateMemberService.java index 1da38dfdc..e46225a9d 100644 --- a/src/main/java/edu/hawaii/its/api/service/UpdateMemberService.java +++ b/src/main/java/edu/hawaii/its/api/service/UpdateMemberService.java @@ -115,8 +115,7 @@ public GroupingMoveMembersResult addIncludeMembers(String currentUser, String gr groupPathService.checkPath(groupingPath); checkIfOwnerOrAdminUser(currentUser, groupingPath); List validIdentifiers = subjectService.getValidUhUuids(uhIdentifiers); - return moveGroupMembers(currentUser, groupingPath + GroupType.INCLUDE.value(), groupingPath + GroupType.EXCLUDE.value(), - validIdentifiers); + return moveGroupMembers(currentUser, groupingPath + GroupType.INCLUDE.value(), groupingPath + GroupType.EXCLUDE.value(), validIdentifiers); } @Async @@ -148,8 +147,7 @@ public GroupingMoveMembersResult addExcludeMembers(String currentUser, String gr groupPathService.checkPath(groupingPath); checkIfOwnerOrAdminUser(currentUser, groupingPath); List validIdentifiers = subjectService.getValidUhUuids(uhIdentifiers); - return moveGroupMembers(currentUser, groupingPath + GroupType.EXCLUDE.value(), - groupingPath + GroupType.INCLUDE.value(), validIdentifiers); + return moveGroupMembers(currentUser, groupingPath + GroupType.EXCLUDE.value(), groupingPath + GroupType.INCLUDE.value(), validIdentifiers); } @Async @@ -209,8 +207,7 @@ public GroupingMoveMemberResult optIn(String currentUser, String groupingPath, S log.info(String.format("optIn; currentUser: %s; groupingPath: %s; uhIdentifier %s;", currentUser, groupingPath, uhIdentifier)); checkIfSelfOptOrAdmin(currentUser, uhIdentifier); - return moveGroupMember(currentUser, groupingPath + GroupType.INCLUDE.value(), groupingPath + GroupType.EXCLUDE.value(), - uhIdentifier); + return moveGroupMember(currentUser, groupingPath + GroupType.INCLUDE.value(), groupingPath + GroupType.EXCLUDE.value(), uhIdentifier); } public GroupingMoveMemberResult optOut(String currentUser, String groupingPath, String uhIdentifier) { diff --git a/src/main/java/edu/hawaii/its/api/util/JsonUtil.java b/src/main/java/edu/hawaii/its/api/util/JsonUtil.java index 30b3fe940..c7705c80e 100644 --- a/src/main/java/edu/hawaii/its/api/util/JsonUtil.java +++ b/src/main/java/edu/hawaii/its/api/util/JsonUtil.java @@ -43,6 +43,7 @@ public static void printJson(Object obj) { logger.error("Error: " + e); } } + public static void prettyPrint(Object object) { try { String json = new ObjectMapper() diff --git a/src/test/java/edu/hawaii/its/api/access/UhCasAttributesTest.java b/src/test/java/edu/hawaii/its/api/access/UhCasAttributesTest.java index ea6e0f7b9..089d4719c 100644 --- a/src/test/java/edu/hawaii/its/api/access/UhCasAttributesTest.java +++ b/src/test/java/edu/hawaii/its/api/access/UhCasAttributesTest.java @@ -218,4 +218,12 @@ public void misc() { assertThat(attributes.toString(), containsString("uid=duckart")); } + + @Test + public void uhCasAttributesTest() { + UhCasAttributes attributes = new UhCasAttributes(); + assertThat(attributes.getUsername(), is("")); + assertThat(attributes.getUhUuid(), is("")); + assertThat(attributes.getUid(), is("")); + } } diff --git a/src/test/java/edu/hawaii/its/api/controller/GroupingsRestControllerv2_1Test.java b/src/test/java/edu/hawaii/its/api/controller/GroupingsRestControllerv2_1Test.java index 181a5e17a..21c8b0171 100644 --- a/src/test/java/edu/hawaii/its/api/controller/GroupingsRestControllerv2_1Test.java +++ b/src/test/java/edu/hawaii/its/api/controller/GroupingsRestControllerv2_1Test.java @@ -69,7 +69,6 @@ import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put; -import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; diff --git a/src/test/java/edu/hawaii/its/api/exception/AccessDeniedExceptionTest.java b/src/test/java/edu/hawaii/its/api/exception/AccessDeniedExceptionTest.java index 46c3511c1..bdd0cc631 100644 --- a/src/test/java/edu/hawaii/its/api/exception/AccessDeniedExceptionTest.java +++ b/src/test/java/edu/hawaii/its/api/exception/AccessDeniedExceptionTest.java @@ -1,9 +1,8 @@ package edu.hawaii.its.api.exception; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; @@ -13,33 +12,33 @@ class AccessDeniedExceptionTest { public void construction() { AccessDeniedException exception = new AccessDeniedException(); assertNotNull(exception); - assertThat(exception.getMessage(), equalTo("Insufficient Privileges")); + assertEquals("Insufficient Privileges", exception.getMessage()); exception = new AccessDeniedException("fail"); assertNotNull(exception); - assertThat(exception.getMessage(), equalTo("fail")); + assertEquals("fail", exception.getMessage()); Throwable throwable = new Throwable(); assertNotNull(throwable); assertNull(throwable.getMessage()); exception = new AccessDeniedException(throwable); assertNotNull(exception); - assertThat(exception.getMessage(), equalTo(throwable.toString())); - assertThat(exception.getMessage(), equalTo("java.lang.Throwable")); - assertThat(exception.getCause(), equalTo(throwable)); + assertEquals(throwable.toString(), exception.getMessage()); + assertEquals("java.lang.Throwable", exception.getMessage()); + assertEquals(throwable, exception.getCause()); throwable = new Throwable("fail"); assertNotNull(throwable); - assertThat(throwable.getMessage(), equalTo("fail")); + assertEquals("fail", throwable.getMessage()); exception = new AccessDeniedException(throwable); assertNotNull(exception); - assertThat(exception.getMessage(), equalTo(throwable.toString())); - assertThat(exception.getMessage(), equalTo("java.lang.Throwable: fail")); - assertThat(exception.getCause(), equalTo(throwable)); + assertEquals(throwable.toString(), exception.getMessage()); + assertEquals("java.lang.Throwable: fail", exception.getMessage()); + assertEquals(throwable, exception.getCause()); exception = new AccessDeniedException("fail", throwable); assertNotNull(exception); - assertThat(exception.getMessage(), equalTo("fail")); - assertThat(exception.getCause(), equalTo(throwable)); + assertEquals("fail", exception.getMessage()); + assertEquals(throwable, exception.getCause()); } } diff --git a/src/test/java/edu/hawaii/its/api/exception/InvalidGroupPathExceptionTest.java b/src/test/java/edu/hawaii/its/api/exception/InvalidGroupPathExceptionTest.java new file mode 100644 index 000000000..e06f04dca --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/exception/InvalidGroupPathExceptionTest.java @@ -0,0 +1,18 @@ +package edu.hawaii.its.api.exception; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; + +public class InvalidGroupPathExceptionTest { + + @Test + public void construction() { + InvalidGroupPathException exception = new InvalidGroupPathException("fail"); + assertNotNull(exception); + assertEquals("404 NOT_FOUND \"fail\"", exception.getMessage()); + + } + +} diff --git a/src/test/java/edu/hawaii/its/api/exception/JavaVersionExceptionTest.java b/src/test/java/edu/hawaii/its/api/exception/JavaVersionExceptionTest.java new file mode 100644 index 000000000..00bfa65e3 --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/exception/JavaVersionExceptionTest.java @@ -0,0 +1,17 @@ +package edu.hawaii.its.api.exception; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; + +public class JavaVersionExceptionTest { + + @Test + public void construction() { + JavaVersionException exception = new JavaVersionException("fail"); + assertNotNull(exception); + assertEquals("fail", exception.getMessage()); + + } +} diff --git a/src/test/java/edu/hawaii/its/api/exception/JavaVersionFailureAnalyzerTest.java b/src/test/java/edu/hawaii/its/api/exception/JavaVersionFailureAnalyzerTest.java new file mode 100644 index 000000000..ae23fd679 --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/exception/JavaVersionFailureAnalyzerTest.java @@ -0,0 +1,17 @@ +package edu.hawaii.its.api.exception; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import org.junit.jupiter.api.Test; + +public class JavaVersionFailureAnalyzerTest { + + @Test + public void analyze() { + JavaVersionFailureAnalyzer javaVersionFailureAnalyzer = new JavaVersionFailureAnalyzer(); + Throwable throwable = new Throwable(); + JavaVersionException exception = new JavaVersionException(""); + assertNotNull(javaVersionFailureAnalyzer.analyze(throwable, exception)); + + } +} diff --git a/src/test/java/edu/hawaii/its/api/exception/PasswordFoundAnalyzerTest.java b/src/test/java/edu/hawaii/its/api/exception/PasswordFoundAnalyzerTest.java new file mode 100644 index 000000000..724a4150e --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/exception/PasswordFoundAnalyzerTest.java @@ -0,0 +1,18 @@ +package edu.hawaii.its.api.exception; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import org.junit.jupiter.api.Test; + +public class PasswordFoundAnalyzerTest { + + @Test + public void analyze() { + PasswordFoundAnalyzer passwordFoundAnalyzer = new PasswordFoundAnalyzer(); + Throwable throwable = new Throwable(); + PasswordFoundException exception = new PasswordFoundException(""); + assertNotNull(passwordFoundAnalyzer.analyze(throwable, exception)); + + } + +} diff --git a/src/test/java/edu/hawaii/its/api/exception/PasswordFoundExceptionTest.java b/src/test/java/edu/hawaii/its/api/exception/PasswordFoundExceptionTest.java new file mode 100644 index 000000000..e6a1cf406 --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/exception/PasswordFoundExceptionTest.java @@ -0,0 +1,16 @@ +package edu.hawaii.its.api.exception; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import org.junit.jupiter.api.Test; +public class PasswordFoundExceptionTest { + + @Test + public void construction() { + PasswordFoundException exception = new PasswordFoundException("location"); + assertNotNull(exception); + assertEquals("location", exception.getMessage()); + + } +} diff --git a/src/test/java/edu/hawaii/its/api/exception/PatternFoundExceptionTest.java b/src/test/java/edu/hawaii/its/api/exception/PatternFoundExceptionTest.java new file mode 100644 index 000000000..d31bf143f --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/exception/PatternFoundExceptionTest.java @@ -0,0 +1,16 @@ +package edu.hawaii.its.api.exception; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import org.junit.jupiter.api.Test; +public class PatternFoundExceptionTest { + + @Test + public void construction() { + PatternFoundException exception = new PatternFoundException("fail"); + assertNotNull(exception); + assertEquals("fail", exception.getMessage()); + + } +} diff --git a/src/test/java/edu/hawaii/its/api/exception/UhMemberNotFoundExceptionTest.java b/src/test/java/edu/hawaii/its/api/exception/UhMemberNotFoundExceptionTest.java index 5154c2586..1403c1753 100644 --- a/src/test/java/edu/hawaii/its/api/exception/UhMemberNotFoundExceptionTest.java +++ b/src/test/java/edu/hawaii/its/api/exception/UhMemberNotFoundExceptionTest.java @@ -1,8 +1,7 @@ package edu.hawaii.its.api.exception; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; @@ -10,8 +9,8 @@ public class UhMemberNotFoundExceptionTest { @Test public void construction() { - UhMemberNotFoundException ex = new UhMemberNotFoundException("fail"); - assertNotNull(ex); - assertThat(ex.getMessage(), equalTo("404 NOT_FOUND \"fail\"")); + UhMemberNotFoundException exception = new UhMemberNotFoundException("fail"); + assertNotNull(exception); + assertEquals("404 NOT_FOUND \"fail\"", exception.getMessage()); } } diff --git a/src/test/java/edu/hawaii/its/api/groupings/GroupingGroupsMembersTest.java b/src/test/java/edu/hawaii/its/api/groupings/GroupingGroupsMembersTest.java index 66a609148..d0e141fa8 100644 --- a/src/test/java/edu/hawaii/its/api/groupings/GroupingGroupsMembersTest.java +++ b/src/test/java/edu/hawaii/its/api/groupings/GroupingGroupsMembersTest.java @@ -168,4 +168,18 @@ public void emptyResult() { assertNotNull(groupingGroupsMembers.getAllMembers().getMembers()); assertTrue(groupingGroupsMembers.getAllMembers().getMembers().isEmpty()); } + + @Test + public void construction() { + GroupingGroupsMembers groupingGroupsMembers = new GroupingGroupsMembers(); + assertEquals("", groupingGroupsMembers.getGroupPath()); + assertEquals("", groupingGroupsMembers.getResultCode()); + assertNotNull(groupingGroupsMembers.getAllMembers()); + assertFalse(groupingGroupsMembers.isBasis()); + assertFalse(groupingGroupsMembers.isInclude()); + assertFalse(groupingGroupsMembers.isExclude()); + assertFalse(groupingGroupsMembers.isOwners()); + assertEquals(Integer.valueOf(0), groupingGroupsMembers.getPageNumber()); + assertTrue(groupingGroupsMembers.isPaginationComplete()); + } } diff --git a/src/test/java/edu/hawaii/its/api/groupings/GroupingMemberTest.java b/src/test/java/edu/hawaii/its/api/groupings/GroupingMemberTest.java new file mode 100644 index 000000000..4a7123ec2 --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/groupings/GroupingMemberTest.java @@ -0,0 +1,49 @@ +package edu.hawaii.its.api.groupings; + +import edu.hawaii.its.api.wrapper.Subject; +import edu.internet2.middleware.grouperClient.ws.beans.WsSubject; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import edu.hawaii.its.api.util.JsonUtil; + +import java.io.FileInputStream; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Properties; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +public class GroupingMemberTest { + private static Properties properties; + + @BeforeAll + public static void beforeAll() throws Exception { + Path path = Paths.get("src/test/resources"); + Path file = path.resolve("grouper.test.properties"); + properties = new Properties(); + properties.load(new FileInputStream(file.toFile())); + } + + @Test + public void construction() { + String json = properties.getProperty("ws.subject.success.uid"); + WsSubject wsSubject = JsonUtil.asObject(json, WsSubject.class); + Subject subject = new Subject(wsSubject); + GroupingGroupMember groupingGroupMember = new GroupingGroupMember(subject); + GroupingMember groupingMember = new GroupingMember(groupingGroupMember, "Include"); + assertNotNull(groupingMember); + + assertEquals("Testf-iwt-a TestIAM-staff", groupingMember.getName()); + assertEquals("99997010", groupingMember.getUhUuid()); + assertEquals("testiwta", groupingMember.getUid()); + assertEquals("Include", groupingMember.getWhereListed()); + + groupingMember = new GroupingMember(); + assertNotNull(groupingMember); + assertNotNull(groupingMember.getName()); + assertNotNull(groupingMember.getUhUuid()); + assertNotNull(groupingMember.getUid()); + assertNotNull(groupingMember.getWhereListed()); + } +} diff --git a/src/test/java/edu/hawaii/its/api/groupings/GroupingSyncDestinationTest.java b/src/test/java/edu/hawaii/its/api/groupings/GroupingSyncDestinationTest.java new file mode 100644 index 000000000..a0fecc96c --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/groupings/GroupingSyncDestinationTest.java @@ -0,0 +1,24 @@ +package edu.hawaii.its.api.groupings; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class GroupingSyncDestinationTest { + + @Test + public void test() { + GroupingSyncDestination dest = new GroupingSyncDestination(); + dest.setDescription("description"); + dest.setName("name"); + dest.setHidden(false); + dest.setSynced(true); + dest.setTooltip("tooltip"); + + assertEquals("description", dest.getDescription()); + assertEquals("name", dest.getName()); + assertEquals(false, dest.getHidden()); + assertEquals(true, dest.getSynced()); + assertEquals("tooltip", dest.getTooltip()); + } +} \ No newline at end of file diff --git a/src/test/java/edu/hawaii/its/api/groupings/GroupingsUpdatedAttributesResultTest.java b/src/test/java/edu/hawaii/its/api/groupings/GroupingsUpdatedAttributesResultTest.java index 38e8964a9..70157bdb9 100644 --- a/src/test/java/edu/hawaii/its/api/groupings/GroupingsUpdatedAttributesResultTest.java +++ b/src/test/java/edu/hawaii/its/api/groupings/GroupingsUpdatedAttributesResultTest.java @@ -26,11 +26,10 @@ public void test() { String json = propertyLocator.find("ws.assign.attributes.results.turn.off.opt.in.success"); WsAssignAttributesResults wsAssignAttributesResults = JsonUtil.asObject(json, WsAssignAttributesResults.class); AssignAttributesResults assignAttributesResults = new AssignAttributesResults(wsAssignAttributesResults); - GroupingUpdatedAttributesResult groupingsUpdatedAttributesResult = - new GroupingUpdatedAttributesResult(assignAttributesResults); + GroupingUpdatedAttributesResult groupingsUpdatedAttributesResult = new GroupingUpdatedAttributesResult(null); assertNotNull(groupingsUpdatedAttributesResult); + groupingsUpdatedAttributesResult = new GroupingUpdatedAttributesResult(assignAttributesResults); assertEquals("SUCCESS", groupingsUpdatedAttributesResult.getResultCode()); assertEquals("group-path", groupingsUpdatedAttributesResult.getGroupPath()); - } } diff --git a/src/test/java/edu/hawaii/its/api/service/AsyncJobsManagerTest.java b/src/test/java/edu/hawaii/its/api/service/AsyncJobsManagerTest.java new file mode 100644 index 000000000..89f32c0c0 --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/service/AsyncJobsManagerTest.java @@ -0,0 +1,88 @@ +package edu.hawaii.its.api.service; + +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; + +import edu.hawaii.its.api.exception.AccessDeniedException; +import edu.hawaii.its.api.type.AsyncJobResult; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class AsyncJobsManagerTest { + + @Mock + private MemberService memberService; + + @InjectMocks + private AsyncJobsManager asyncJobsManager; + + @BeforeEach + public void setUp() { + MockitoAnnotations.openMocks(this); + ReflectionTestUtils.setField(asyncJobsManager, "jobMap", new ConcurrentHashMap<>()); + } + + @Test + public void getJobResultNotFoundTest() { + String currentUser = "currentUser"; + Integer jobId = 0; + when(memberService.isAdmin(currentUser)).thenReturn(true); + when(memberService.isOwner(currentUser)).thenReturn(true); + AsyncJobResult asyncJobResult = asyncJobsManager.getJobResult(currentUser, jobId); + assertEquals("NOT_FOUND", asyncJobResult.getStatus()); + + when(memberService.isAdmin(currentUser)).thenReturn(false); + when(memberService.isOwner(currentUser)).thenReturn(true); + CompletableFuture job = CompletableFuture.completedFuture(anyString()); + asyncJobsManager.putJob(job); + AsyncJobResult result = asyncJobsManager.getJobResult(currentUser, jobId); + assertEquals("NOT_FOUND", result.getStatus()); + } + + @Test + public void getJobResultInProgressTest() { + String currentUser = "currentUser"; + Integer jobId = asyncJobsManager.putJob(new CompletableFuture<>()); + when(memberService.isAdmin(currentUser)).thenReturn(true); + when(memberService.isOwner(currentUser)).thenReturn(true); + CompletableFuture inProgressJob = new CompletableFuture<>(); + asyncJobsManager.putJob(inProgressJob); + AsyncJobResult asyncJobResult = asyncJobsManager.getJobResult(currentUser, jobId); + assertFalse(inProgressJob.isDone()); + assertEquals("IN_PROGRESS", asyncJobResult.getStatus()); + } + + @Test + public void getJobResultCompletedTest() { + String currentUser = "currentUser"; + Integer jobId = asyncJobsManager.putJob(CompletableFuture.completedFuture(anyString())); + when(memberService.isAdmin(currentUser)).thenReturn(true); + when(memberService.isOwner(currentUser)).thenReturn(true); + CompletableFuture completedJob = new CompletableFuture<>(); + asyncJobsManager.putJob(completedJob); + AsyncJobResult asyncJobResult = asyncJobsManager.getJobResult(currentUser, jobId); + assertEquals("COMPLETED", asyncJobResult.getStatus()); + } + + @Test + public void getJobResultDeniedTest() { + String currentUser = "currentUser"; + Integer jobId = 0; + when(memberService.isAdmin(currentUser)).thenReturn(false); + when(memberService.isOwner(currentUser)).thenReturn(false); + assertThrows(AccessDeniedException.class, () -> asyncJobsManager.getJobResult(currentUser, jobId)); + } + +} \ No newline at end of file diff --git a/src/test/java/edu/hawaii/its/api/service/ExecutorServiceTest.java b/src/test/java/edu/hawaii/its/api/service/ExecutorServiceTest.java new file mode 100644 index 000000000..f0e6aec8c --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/service/ExecutorServiceTest.java @@ -0,0 +1,35 @@ +package edu.hawaii.its.api.service; + +import edu.hawaii.its.api.wrapper.Command; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class ExecutorServiceTest { + + @Mock + private Command mockCommand; + + @Mock + private ExecutorService executorService; + + @BeforeEach + public void setUp() { + MockitoAnnotations.openMocks(this); + executorService = new ExecutorService(); + } + + @Test + public void executeTest() { + when(mockCommand.execute()).thenReturn("execution success"); + assertNotNull(executorService.execute(mockCommand)); + assertEquals("execution success", executorService.execute(mockCommand)); + + when(mockCommand.execute()).thenThrow(new RuntimeException("execution error")); + assertNull(executorService.execute(mockCommand)); + } +} \ No newline at end of file diff --git a/src/test/java/edu/hawaii/its/api/service/GroupingAssignmentServiceTest.java b/src/test/java/edu/hawaii/its/api/service/GroupingAssignmentServiceTest.java index ac3e6ca53..011d3b72a 100644 --- a/src/test/java/edu/hawaii/its/api/service/GroupingAssignmentServiceTest.java +++ b/src/test/java/edu/hawaii/its/api/service/GroupingAssignmentServiceTest.java @@ -12,16 +12,13 @@ import org.junit.jupiter.api.TestInstance; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; import java.util.Map; -import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; @TestInstance(TestInstance.Lifecycle.PER_CLASS) @SpringBootTest(classes = { SpringBootWebApplication.class }) @@ -60,4 +57,4 @@ public void makeGroupsTest() { Group resultGroup = groups.get(GROUPING_0_PATH); } -} +} \ No newline at end of file diff --git a/src/test/java/edu/hawaii/its/api/service/JavaVersionCheckerTest.java b/src/test/java/edu/hawaii/its/api/service/JavaVersionCheckerTest.java index 742bfcecb..e13adf71e 100644 --- a/src/test/java/edu/hawaii/its/api/service/JavaVersionCheckerTest.java +++ b/src/test/java/edu/hawaii/its/api/service/JavaVersionCheckerTest.java @@ -3,21 +3,39 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertThrows; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfSystemProperty; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; +import org.junit.jupiter.api.BeforeEach; + +import org.mockito.MockitoAnnotations; +import org.springframework.test.util.ReflectionTestUtils; -import edu.hawaii.its.api.configuration.SpringBootWebApplication; import edu.hawaii.its.api.exception.JavaVersionException; -@EnabledIfSystemProperty(named = "spring.profiles.active", matches = "localhost") -@SpringBootTest(classes = { SpringBootWebApplication.class }) public class JavaVersionCheckerTest { - @Autowired + private JavaVersionChecker javaVersionChecker; + @BeforeEach + public void beforeEach() { + MockitoAnnotations.openMocks(this); + javaVersionChecker = new JavaVersionChecker(); + ReflectionTestUtils.setField(javaVersionChecker, "javaSpecificationVersion", "1.8"); + } + + @Test + public void initCorrectVersionTest() { + System.setProperty("java.version", "1.8"); + assertDoesNotThrow(() -> javaVersionChecker.init()); + } + + @Test + public void initIncorrectVersionTest() { + System.setProperty("java.version", "1.9"); + assertThrows(JavaVersionException.class, () -> javaVersionChecker.init()); + } + + +/* private final String currentJavaVersion = System.getProperty("java.version"); @Test @@ -37,4 +55,6 @@ public void testIncorrectVersion() { public void testCorrectVersion() { assertDoesNotThrow(() -> javaVersionChecker.init()); } + */ + } diff --git a/src/test/java/edu/hawaii/its/api/service/MemberServiceTest.java b/src/test/java/edu/hawaii/its/api/service/MemberServiceTest.java new file mode 100644 index 000000000..58d115e8e --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/service/MemberServiceTest.java @@ -0,0 +1,128 @@ +package edu.hawaii.its.api.service; + +import edu.hawaii.its.api.type.GroupType; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import edu.hawaii.its.api.configuration.SpringBootWebApplication; +import edu.hawaii.its.api.util.JsonUtil; +import edu.hawaii.its.api.util.PropertyLocator; +import edu.hawaii.its.api.wrapper.HasMembersResults; + +import edu.internet2.middleware.grouperClient.ws.beans.WsHasMemberResults; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.mock.mockito.SpyBean; +import org.springframework.test.context.ActiveProfiles; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.doReturn; + +@ActiveProfiles("localTest") +@SpringBootTest(classes = { SpringBootWebApplication.class }) +public class MemberServiceTest { + @Value("${groupings.api.test.uh-usernames}") + private List TEST_USERNAMES; + + private String groupingPath = "grouping-path"; + + @Value("${groupings.api.grouping_admins}") + private String GROUPING_ADMINS; + + @Value("${groupings.api.grouping_owners}") + private String OWNERS_GROUP; + + private PropertyLocator propertyLocator; + + @SpyBean + private GrouperApiService grouperApiService; + + @Autowired + private MemberService memberService; + + @BeforeEach + public void beforeEach() throws Exception { + propertyLocator = new PropertyLocator("src/test/resources", "grouper.test.properties"); + } + + @Test + public void isAdminTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + assertTrue(memberService.isAdmin(TEST_USERNAMES.get(0))); + } + + @Test + public void isOwnerTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupingPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(OWNERS_GROUP, TEST_USERNAMES.get(0)); + + assertTrue(memberService.isOwner(groupingPath, TEST_USERNAMES.get(0))); + assertTrue(memberService.isOwner(TEST_USERNAMES.get(0))); + } + + @Test + public void isIncludeTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupingPath + GroupType.INCLUDE.value(), TEST_USERNAMES.get(0)); + + assertTrue(memberService.isInclude(groupingPath, TEST_USERNAMES.get(0))); + } + + @Test + public void isExcludeTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupingPath + GroupType.EXCLUDE.value(), TEST_USERNAMES.get(0)); + + assertTrue(memberService.isExclude(groupingPath, TEST_USERNAMES.get(0))); + } + + @Test + public void isMemberTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupingPath, TEST_USERNAMES.get(0)); + + assertTrue(memberService.isMember(groupingPath, TEST_USERNAMES.get(0))); + } + + @Test + public void isMemberNullTest() { + String json = propertyLocator.find("ws.has.member.results.null.group"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupingPath, TEST_USERNAMES.get(0)); + + assertFalse(memberService.isMember(groupingPath, TEST_USERNAMES.get(0))); + } + +} diff --git a/src/test/java/edu/hawaii/its/api/service/PathFilterTest.java b/src/test/java/edu/hawaii/its/api/service/PathFilterTest.java index 93d78c2fd..64dd19aa6 100644 --- a/src/test/java/edu/hawaii/its/api/service/PathFilterTest.java +++ b/src/test/java/edu/hawaii/its/api/service/PathFilterTest.java @@ -109,6 +109,9 @@ public void testParentGroupingPath() { } assertThat(parentGroupingPath(groupinPath), equalTo(groupinPath)); + PathFilter pathFilter = new PathFilter(); + assertEquals("", pathFilter.parentGroupingPath(null)); + assertEquals("", pathFilter.parentGroupingPath("")); } @Test diff --git a/src/test/java/edu/hawaii/its/api/service/UpdateMemberServiceTest.java b/src/test/java/edu/hawaii/its/api/service/UpdateMemberServiceTest.java new file mode 100644 index 000000000..34799bede --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/service/UpdateMemberServiceTest.java @@ -0,0 +1,408 @@ +package edu.hawaii.its.api.service; + +import edu.hawaii.its.api.configuration.SpringBootWebApplication; +import edu.hawaii.its.api.exception.UhMemberNotFoundException; +import edu.hawaii.its.api.type.GroupType; +import edu.hawaii.its.api.util.JsonUtil; +import edu.hawaii.its.api.util.PropertyLocator; +import edu.hawaii.its.api.wrapper.*; +import edu.internet2.middleware.grouperClient.ws.beans.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.mock.mockito.SpyBean; +import org.springframework.test.context.ActiveProfiles; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.doReturn; + +@ActiveProfiles("localTest") +@SpringBootTest(classes = { SpringBootWebApplication.class }) +public class UpdateMemberServiceTest { + + @Autowired + private SubjectService subjectService; + + @Autowired + private UpdateMemberService updateMemberService; + + @Autowired + private GroupPathService groupPathService; + + private PropertyLocator propertyLocator; + + @SpyBean + private GrouperApiService grouperApiService; + + @Value("${groupings.api.grouping_admins}") + private String GROUPING_ADMINS; + + @Value("${groupings.api.test.uh-usernames}") + private List TEST_USERNAMES; + + private String groupPath = "group-path"; + + @BeforeEach + public void beforeEach() throws Exception { + propertyLocator = new PropertyLocator("src/test/resources", "grouper.test.properties"); + } + + @Test + public void addAdminTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(1)); + + json = propertyLocator.find("ws.get.subject.result.success"); + WsGetSubjectsResults wsGetSubjectsResults = JsonUtil.asObject(json, WsGetSubjectsResults.class); + SubjectsResults subjectsResults = new SubjectsResults(wsGetSubjectsResults); + assertNotNull(subjectsResults); + doReturn(subjectsResults).when(grouperApiService).getSubjects(TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.add.member.results.success"); + WsAddMemberResults wsAddMemberResults = JsonUtil.asObject(json, WsAddMemberResults.class); + AddMemberResult addMemberResult = new AddMemberResult(wsAddMemberResults.getResults()[0], groupPath); + assertNotNull(addMemberResult); + doReturn(addMemberResult).when(grouperApiService).addMember(TEST_USERNAMES.get(1), GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + assertNotNull(updateMemberService.addAdmin(TEST_USERNAMES.get(1), TEST_USERNAMES.get(0))); + + json = propertyLocator.find("ws.get.subject.result.uid.failure"); + wsGetSubjectsResults = JsonUtil.asObject(json, WsGetSubjectsResults.class); + subjectsResults = new SubjectsResults(wsGetSubjectsResults); + assertNotNull(subjectsResults); + doReturn(subjectsResults).when(grouperApiService).getSubjects("bogus-identifier"); + + assertThrows(UhMemberNotFoundException.class, + () -> updateMemberService.addAdmin(TEST_USERNAMES.get(1), "bogus-identifier")); + } + + @Test + public void removeAdminTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(1)); + + json = propertyLocator.find("ws.get.subject.result.success"); + WsGetSubjectsResults wsGetSubjectsResults = JsonUtil.asObject(json, WsGetSubjectsResults.class); + SubjectsResults subjectsResults = new SubjectsResults(wsGetSubjectsResults); + assertNotNull(subjectsResults); + doReturn(subjectsResults).when(grouperApiService).getSubjects(TEST_USERNAMES.get(0)); + + RemoveMemberResult removeMemberResult = new RemoveMemberResult(); + assertNotNull(removeMemberResult); + doReturn(removeMemberResult).when(grouperApiService).removeMember(TEST_USERNAMES.get(1), GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + assertNotNull(updateMemberService.removeAdmin(TEST_USERNAMES.get(1), TEST_USERNAMES.get(0))); + + json = propertyLocator.find("ws.get.subject.result.uid.failure"); + wsGetSubjectsResults = JsonUtil.asObject(json, WsGetSubjectsResults.class); + subjectsResults = new SubjectsResults(wsGetSubjectsResults); + assertNotNull(subjectsResults); + doReturn(subjectsResults).when(grouperApiService).getSubjects("bogus-identifier"); + + assertThrows(UhMemberNotFoundException.class, + () -> updateMemberService.removeAdmin(TEST_USERNAMES.get(1), "bogus-identifier")); + } + + @Test + public void addOwnershipsTest() { + String json = propertyLocator.find("find.groups.results.description"); + WsFindGroupsResults wsFindGroupsResults = JsonUtil.asObject(json, WsFindGroupsResults.class); + FindGroupsResults findGroupsResults = new FindGroupsResults(wsFindGroupsResults); + assertNotNull(findGroupsResults); + doReturn(findGroupsResults).when(grouperApiService).findGroupsResults(groupPath); + + json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.get.subjects.results.success"); + WsGetSubjectsResults wsGetSubjectsResults = JsonUtil.asObject(json, WsGetSubjectsResults.class); + SubjectsResults subjectsResults = new SubjectsResults(wsGetSubjectsResults); + doReturn(subjectsResults).when(grouperApiService).getSubjects(TEST_USERNAMES); + + json = propertyLocator.find("ws.add.member.results.failure"); + WsAddMemberResults wsAddMemberResults = JsonUtil.asObject(json, WsAddMemberResults.class); + AddMembersResults addMembersResults = new AddMembersResults(wsAddMemberResults); + List validIdentifiers = subjectService.getValidUhUuids(TEST_USERNAMES); + doReturn(addMembersResults).when(grouperApiService).addMembers(TEST_USERNAMES.get(0), groupPath + GroupType.OWNERS.value(), validIdentifiers); + + assertNotNull(updateMemberService.addOwnerships(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES)); + } + + @Test + public void removeOwnershipsTest() { + String json = propertyLocator.find("find.groups.results.description"); + WsFindGroupsResults wsFindGroupsResults = JsonUtil.asObject(json, WsFindGroupsResults.class); + FindGroupsResults findGroupsResults = new FindGroupsResults(wsFindGroupsResults); + assertNotNull(findGroupsResults); + doReturn(findGroupsResults).when(grouperApiService).findGroupsResults(groupPath); + + json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.get.subjects.results.success"); + WsGetSubjectsResults wsGetSubjectsResults = JsonUtil.asObject(json, WsGetSubjectsResults.class); + SubjectsResults subjectsResults = new SubjectsResults(wsGetSubjectsResults); + doReturn(subjectsResults).when(grouperApiService).getSubjects(TEST_USERNAMES); + + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + RemoveMembersResults removeMembersResults = new RemoveMembersResults(wsDeleteMemberResults); + List validIdentifiers = subjectService.getValidUhUuids(TEST_USERNAMES); + doReturn(removeMembersResults).when(grouperApiService).removeMembers(TEST_USERNAMES.get(0), groupPath + GroupType.OWNERS.value(), validIdentifiers); + + assertNotNull(updateMemberService.removeOwnerships(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES)); + } + + @Test + public void addIncludeMembersTest() { + String json = propertyLocator.find("find.groups.results.description"); + WsFindGroupsResults wsFindGroupsResults = JsonUtil.asObject(json, WsFindGroupsResults.class); + FindGroupsResults findGroupsResults = new FindGroupsResults(wsFindGroupsResults); + assertNotNull(findGroupsResults); + doReturn(findGroupsResults).when(grouperApiService).findGroupsResults(groupPath); + + json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.get.subjects.results.success"); + WsGetSubjectsResults wsGetSubjectsResults = JsonUtil.asObject(json, WsGetSubjectsResults.class); + SubjectsResults subjectsResults = new SubjectsResults(wsGetSubjectsResults); + doReturn(subjectsResults).when(grouperApiService).getSubjects(TEST_USERNAMES); + + List validIdentifiers = subjectService.getValidUhUuids(TEST_USERNAMES); + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + RemoveMembersResults removeMembersResults = new RemoveMembersResults(wsDeleteMemberResults); + doReturn(removeMembersResults).when(grouperApiService).removeMembers(TEST_USERNAMES.get(0), groupPath + GroupType.EXCLUDE.value(), validIdentifiers); + + json = propertyLocator.find("ws.add.member.results.failure"); + WsAddMemberResults wsAddMemberResults = JsonUtil.asObject(json, WsAddMemberResults.class); + AddMembersResults addMembersResults = new AddMembersResults(wsAddMemberResults); + doReturn(addMembersResults).when(grouperApiService).addMembers(TEST_USERNAMES.get(0), groupPath + GroupType.INCLUDE.value(), validIdentifiers); + + assertNotNull(updateMemberService.addIncludeMembers(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES)); + } + + @Test + public void addExcludeMembersTest() { + String json = propertyLocator.find("find.groups.results.description"); + WsFindGroupsResults wsFindGroupsResults = JsonUtil.asObject(json, WsFindGroupsResults.class); + FindGroupsResults findGroupsResults = new FindGroupsResults(wsFindGroupsResults); + assertNotNull(findGroupsResults); + doReturn(findGroupsResults).when(grouperApiService).findGroupsResults(groupPath); + + json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.get.subjects.results.success"); + WsGetSubjectsResults wsGetSubjectsResults = JsonUtil.asObject(json, WsGetSubjectsResults.class); + SubjectsResults subjectsResults = new SubjectsResults(wsGetSubjectsResults); + doReturn(subjectsResults).when(grouperApiService).getSubjects(TEST_USERNAMES); + + List validIdentifiers = subjectService.getValidUhUuids(TEST_USERNAMES); + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + RemoveMembersResults removeMembersResults = new RemoveMembersResults(wsDeleteMemberResults); + doReturn(removeMembersResults).when(grouperApiService).removeMembers(TEST_USERNAMES.get(0), groupPath + GroupType.INCLUDE.value(), validIdentifiers); + + json = propertyLocator.find("ws.add.member.results.failure"); + WsAddMemberResults wsAddMemberResults = JsonUtil.asObject(json, WsAddMemberResults.class); + AddMembersResults addMembersResults = new AddMembersResults(wsAddMemberResults); + doReturn(addMembersResults).when(grouperApiService).addMembers(TEST_USERNAMES.get(0), groupPath + GroupType.EXCLUDE.value(), validIdentifiers); + + assertNotNull(updateMemberService.addExcludeMembers(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES)); + } + + @Test + public void removeIncludeMembersTest() { + String json = propertyLocator.find("find.groups.results.description"); + WsFindGroupsResults wsFindGroupsResults = JsonUtil.asObject(json, WsFindGroupsResults.class); + FindGroupsResults findGroupsResults = new FindGroupsResults(wsFindGroupsResults); + assertNotNull(findGroupsResults); + doReturn(findGroupsResults).when(grouperApiService).findGroupsResults(groupPath); + + json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + RemoveMembersResults removeMembersResults = new RemoveMembersResults(wsDeleteMemberResults); + assertNotNull(removeMembersResults); + doReturn(removeMembersResults).when(grouperApiService).removeMembers(TEST_USERNAMES.get(0), groupPath + GroupType.INCLUDE.value(), TEST_USERNAMES); + + assertNotNull(updateMemberService.removeIncludeMembers(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES)); + } + + @Test + public void removeIncludeMemberTest() { + String json = propertyLocator.find("find.groups.results.description"); + WsFindGroupsResults wsFindGroupsResults = JsonUtil.asObject(json, WsFindGroupsResults.class); + FindGroupsResults findGroupsResults = new FindGroupsResults(wsFindGroupsResults); + assertNotNull(findGroupsResults); + doReturn(findGroupsResults).when(grouperApiService).findGroupsResults(groupPath); + + json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + assertNotNull(wsDeleteMemberResults); + WsDeleteMemberResult wsDeleteMemberResult = wsDeleteMemberResults.getResults()[0]; + assertNotNull(wsDeleteMemberResult); + RemoveMemberResult removeMemberResult = new RemoveMemberResult(wsDeleteMemberResult, "group-path"); + assertNotNull(removeMemberResult); + doReturn(removeMemberResult).when(grouperApiService).removeMember(TEST_USERNAMES.get(0), groupPath + GroupType.INCLUDE.value(), TEST_USERNAMES.get(1)); + + assertNotNull(updateMemberService.removeIncludeMember(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES.get(1))); + } + + @Test + public void removeExcludeMembersTest() { + String json = propertyLocator.find("find.groups.results.description"); + WsFindGroupsResults wsFindGroupsResults = JsonUtil.asObject(json, WsFindGroupsResults.class); + FindGroupsResults findGroupsResults = new FindGroupsResults(wsFindGroupsResults); + assertNotNull(findGroupsResults); + doReturn(findGroupsResults).when(grouperApiService).findGroupsResults(groupPath); + + json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + RemoveMembersResults removeMembersResults = new RemoveMembersResults(wsDeleteMemberResults); + assertNotNull(removeMembersResults); + doReturn(removeMembersResults).when(grouperApiService).removeMembers(TEST_USERNAMES.get(0), groupPath + GroupType.EXCLUDE.value(), TEST_USERNAMES); + + assertNotNull(updateMemberService.removeExcludeMembers(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES)); + } + + @Test + public void removeExcludeMemberTest() { + String json = propertyLocator.find("find.groups.results.description"); + WsFindGroupsResults wsFindGroupsResults = JsonUtil.asObject(json, WsFindGroupsResults.class); + FindGroupsResults findGroupsResults = new FindGroupsResults(wsFindGroupsResults); + assertNotNull(findGroupsResults); + doReturn(findGroupsResults).when(grouperApiService).findGroupsResults(groupPath); + + json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + assertNotNull(wsDeleteMemberResults); + WsDeleteMemberResult wsDeleteMemberResult = wsDeleteMemberResults.getResults()[0]; + assertNotNull(wsDeleteMemberResult); + RemoveMemberResult removeMemberResult = new RemoveMemberResult(wsDeleteMemberResult, "group-path"); + assertNotNull(removeMemberResult); + doReturn(removeMemberResult).when(grouperApiService).removeMember(TEST_USERNAMES.get(0), groupPath + GroupType.EXCLUDE.value(), TEST_USERNAMES.get(1)); + + assertNotNull(updateMemberService.removeExcludeMember(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES.get(1))); + } + + @Test + public void optInTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + assertNotNull(wsDeleteMemberResults); + WsDeleteMemberResult wsDeleteMemberResult = wsDeleteMemberResults.getResults()[0]; + assertNotNull(wsDeleteMemberResult); + RemoveMemberResult removeMemberResult = new RemoveMemberResult(wsDeleteMemberResult, "group-path"); + assertNotNull(removeMemberResult); + doReturn(removeMemberResult).when(grouperApiService).removeMember(TEST_USERNAMES.get(0), groupPath + GroupType.EXCLUDE.value(), TEST_USERNAMES.get(1)); + + json = propertyLocator.find("ws.add.member.results.success"); + WsAddMemberResults wsAddMemberResults = JsonUtil.asObject(json, WsAddMemberResults.class); + AddMemberResult addMemberResult = new AddMemberResult(wsAddMemberResults.getResults()[0], groupPath); + assertNotNull(addMemberResult); + doReturn(addMemberResult).when(grouperApiService).addMember(TEST_USERNAMES.get(0), groupPath + GroupType.INCLUDE.value(), TEST_USERNAMES.get(1)); + + assertNotNull(updateMemberService.optIn(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES.get(1))); + } + + @Test + public void optOutTest() { + String json = propertyLocator.find("ws.has.member.results.is.members.uhuuid"); + WsHasMemberResults wsHasMemberResults = JsonUtil.asObject(json, WsHasMemberResults.class); + HasMembersResults hasMembersResults = new HasMembersResults(wsHasMemberResults); + assertNotNull(hasMembersResults); + doReturn(hasMembersResults).when(grouperApiService) + .hasMemberResults(groupPath + GroupType.OWNERS.value(), TEST_USERNAMES.get(0)); + doReturn(hasMembersResults).when(grouperApiService).hasMemberResults(GROUPING_ADMINS, TEST_USERNAMES.get(0)); + + json = propertyLocator.find("ws.delete.member.results.failure"); + WsDeleteMemberResults wsDeleteMemberResults = JsonUtil.asObject(json, WsDeleteMemberResults.class); + assertNotNull(wsDeleteMemberResults); + WsDeleteMemberResult wsDeleteMemberResult = wsDeleteMemberResults.getResults()[0]; + assertNotNull(wsDeleteMemberResult); + RemoveMemberResult removeMemberResult = new RemoveMemberResult(wsDeleteMemberResult, "group-path"); + assertNotNull(removeMemberResult); + doReturn(removeMemberResult).when(grouperApiService).removeMember(TEST_USERNAMES.get(0), groupPath + GroupType.INCLUDE.value(), TEST_USERNAMES.get(1)); + + json = propertyLocator.find("ws.add.member.results.success"); + WsAddMemberResults wsAddMemberResults = JsonUtil.asObject(json, WsAddMemberResults.class); + AddMemberResult addMemberResult = new AddMemberResult(wsAddMemberResults.getResults()[0], groupPath); + assertNotNull(addMemberResult); + doReturn(addMemberResult).when(grouperApiService).addMember(TEST_USERNAMES.get(0), groupPath + GroupType.EXCLUDE.value(), TEST_USERNAMES.get(1)); + + assertNotNull(updateMemberService.optOut(TEST_USERNAMES.get(0), groupPath, TEST_USERNAMES.get(1))); + } + +} diff --git a/src/test/java/edu/hawaii/its/api/type/GroupTest.java b/src/test/java/edu/hawaii/its/api/type/GroupTest.java index 1b2a9271f..8fbd41409 100644 --- a/src/test/java/edu/hawaii/its/api/type/GroupTest.java +++ b/src/test/java/edu/hawaii/its/api/type/GroupTest.java @@ -282,4 +282,5 @@ public void isEmptyTest() { group.addMember(new Person("A", "B", "C")); assertFalse(group.isEmpty()); } + } diff --git a/src/test/java/edu/hawaii/its/api/type/GroupingServiceResultExceptionTest.java b/src/test/java/edu/hawaii/its/api/type/GroupingServiceResultExceptionTest.java index f7f8c5d09..2e36f7750 100644 --- a/src/test/java/edu/hawaii/its/api/type/GroupingServiceResultExceptionTest.java +++ b/src/test/java/edu/hawaii/its/api/type/GroupingServiceResultExceptionTest.java @@ -29,4 +29,24 @@ public void construction() { String expected = test.replaceAll("\\\\", ""); assertThat(groupingsServiceResultException.getGsr().toString(), equalTo(expected)); } + + @Test + public void constructorTest() { + GroupingsServiceResultException exception = new GroupingsServiceResultException(); + assertNull(exception.getGsr()); + } + @Test + public void getGsrTest() { + GroupingsServiceResult groupingsServiceResult = new GroupingsServiceResult(); + GroupingsServiceResultException exception = new GroupingsServiceResultException(groupingsServiceResult); + assertThat(exception.getGsr(), equalTo(groupingsServiceResult)); + } + + @Test + public void setGsrTest() { + GroupingsServiceResult groupingsServiceResult = new GroupingsServiceResult(); + GroupingsServiceResultException exception = new GroupingsServiceResultException(); + exception.setGsr(groupingsServiceResult); + assertThat(exception.getGsr(), equalTo(groupingsServiceResult)); + } } \ No newline at end of file diff --git a/src/test/java/edu/hawaii/its/api/type/MembershipTest.java b/src/test/java/edu/hawaii/its/api/type/MembershipTest.java index 2ab0e251f..f8c1ed010 100644 --- a/src/test/java/edu/hawaii/its/api/type/MembershipTest.java +++ b/src/test/java/edu/hawaii/its/api/type/MembershipTest.java @@ -129,4 +129,25 @@ public void optOutEnabledTest() { assertTrue(membershipEmptyOnConstruction.isOptOutEnabled()); } + @Test + public void toStringTest() { + Membership membership = new Membership(); + assertEquals("Membership{" + + "identifier='null'" + + ", person=null" + + ", group=null" + + ", path='null'" + + ", name='null'" + + ", description='null'" + + ", isSelfOpted=false" + + ", isOptInEnabled=false" + + ", isOptOutEnabled=false" + + ", inBasis=false" + + ", inInclude=false" + + ", inExclude=false" + + ", inOwner=false" + + ", inBasisAndInclude=false" + + '}' + , membership.toString()); + } } diff --git a/src/test/java/edu/hawaii/its/api/type/PersonTest.java b/src/test/java/edu/hawaii/its/api/type/PersonTest.java index e6bb933f5..c75b243aa 100644 --- a/src/test/java/edu/hawaii/its/api/type/PersonTest.java +++ b/src/test/java/edu/hawaii/its/api/type/PersonTest.java @@ -10,6 +10,7 @@ import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertTrue; +import edu.hawaii.its.api.wrapper.Subject; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -291,4 +292,15 @@ public void toStringTest() { String expected = "Person [" + "name=" + name + ", uhUuid=" + uhUuid + ", username=" + uid + "]"; assertEquals(expected, person.toString()); } + + @Test + public void subjectConstructorTest() { + Subject subject = new Subject(); + Person person = new Person(subject); + assertThat(person.getName(), is(subject.getName())); + assertThat(person.getUhUuid(), is(subject.getUhUuid())); + assertThat(person.getUsername(), is(subject.getUid())); + assertThat(person.getFirstName(), is(subject.getFirstName())); + assertThat(person.getLastName(), is(subject.getLastName())); + } } diff --git a/src/test/java/edu/hawaii/its/api/util/DatesTest.java b/src/test/java/edu/hawaii/its/api/util/DatesTest.java index d958e7786..9fecf91cb 100644 --- a/src/test/java/edu/hawaii/its/api/util/DatesTest.java +++ b/src/test/java/edu/hawaii/its/api/util/DatesTest.java @@ -657,18 +657,18 @@ public void formatDateBasicPattern() throws Exception { @Test public void dateToLocalDate() { - LocalDate d = Dates.newLocalDate(2016, Month.OCTOBER, 31); - assertThat(d.getDayOfMonth(), is(31)); - assertThat(d.getYear(), is(2016)); - assertThat(d.getMonth(), is(Month.OCTOBER)); + LocalDate date = Dates.newLocalDate(2016, Month.OCTOBER, 31); + assertThat(date.getDayOfMonth(), is(31)); + assertThat(date.getYear(), is(2016)); + assertThat(date.getMonth(), is(Month.OCTOBER)); } @Test public void dateToLocalDateTime() { - LocalDateTime d = Dates.newLocalDateTime(2017, Month.MARCH, 28); - assertThat(d.getDayOfMonth(), is(28)); - assertThat(d.getYear(), is(2017)); - assertThat(d.getMonth(), is(Month.MARCH)); + LocalDateTime date = Dates.newLocalDateTime(2017, Month.MARCH, 28); + assertThat(date.getDayOfMonth(), is(28)); + assertThat(date.getYear(), is(2017)); + assertThat(date.getMonth(), is(Month.MARCH)); } @Test @@ -687,4 +687,16 @@ public void testConstructorIsPrivate() throws Exception { constructor.setAccessible(true); constructor.newInstance(); } + + @Test + public void testToLocalDate() { + java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis()); + LocalDate date1 = Dates.toLocalDate(sqlDate); + assertThat(sqlDate.getTime(), is(sqlDate.getTime())); + assertThat(date1.getYear(), is(LocalDate.now().getYear())); + assertThat(date1.getMonth(), is(LocalDate.now().getMonth())); + assertThat(date1.getDayOfMonth(), is(LocalDate.now().getDayOfMonth())); + LocalDate date2 = Dates.toLocalDate(sqlDate); + assertThat(date2, is(date1)); + } } diff --git a/src/test/java/edu/hawaii/its/api/util/JsonUtilTest.java b/src/test/java/edu/hawaii/its/api/util/JsonUtilTest.java index fa0067e11..316178c2f 100644 --- a/src/test/java/edu/hawaii/its/api/util/JsonUtilTest.java +++ b/src/test/java/edu/hawaii/its/api/util/JsonUtilTest.java @@ -1,19 +1,43 @@ package edu.hawaii.its.api.util; import edu.hawaii.its.api.type.Person; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class JsonUtilTest { + private final ByteArrayOutputStream outStream = new ByteArrayOutputStream(); + private final ByteArrayOutputStream errStream = new ByteArrayOutputStream(); + private Person person0; + + @BeforeAll + public void beforeAll() { + person0 = new Person("name", "uhUuid", "username", "firstName", "lastName"); + } + + @BeforeEach + public void beforeEach() { + System.setOut(new PrintStream(outStream)); + System.setErr(new PrintStream(errStream)); + } + @Test - public void basics() { - Person person0 = new Person("name", "uhUuid", "username", "firstName", "lastName"); + public void asJsonAsObjectTest() { String personJson = JsonUtil.asJson(person0); Person person1 = JsonUtil.asObject(personJson, Person.class); @@ -25,6 +49,22 @@ public void basics() { assertEquals(person0.getLastName(), person1.getLastName()); assertEquals(person0.getAttributes(), person1.getAttributes()); assertEquals(person0.getClass(), person1.getClass()); + assertDoesNotThrow(() -> JsonUtil.asJson(mock(Object.class))); + assertDoesNotThrow(() -> JsonUtil.asObject("", Object.class)); + } + + @Test + public void prettyPrintTest() { + JsonUtil.prettyPrint(person0); + assertTrue(outStream.toString().contains("name")); + assertDoesNotThrow(() -> JsonUtil.prettyPrint(mock(Object.class))); + } + + @Test + public void printJsonTest() { + JsonUtil.printJson(person0); + assertFalse(errStream.toString().trim().isEmpty()); + assertDoesNotThrow(() -> JsonUtil.printJson(mock(Object.class))); } @Test @@ -39,6 +79,12 @@ public void problems() { assertEquals(json, "\"mistake\""); } + @Test + public void prettyPrint() { + JsonUtil.prettyPrint(person0); + assertTrue(outStream.toString().contains("name")); + } + @Test public void constructorIsPrivate() throws Exception { Constructor constructor = JsonUtil.class.getDeclaredConstructor(); @@ -46,4 +92,4 @@ public void constructorIsPrivate() throws Exception { constructor.setAccessible(true); constructor.newInstance(); } -} \ No newline at end of file +} diff --git a/src/test/java/edu/hawaii/its/api/util/OnlyUniqueItemsTest.java b/src/test/java/edu/hawaii/its/api/util/OnlyUniqueItemsTest.java index 61fb1b537..bfd44ba26 100644 --- a/src/test/java/edu/hawaii/its/api/util/OnlyUniqueItemsTest.java +++ b/src/test/java/edu/hawaii/its/api/util/OnlyUniqueItemsTest.java @@ -1,5 +1,7 @@ package edu.hawaii.its.api.util; +import org.hamcrest.Description; +import org.hamcrest.StringDescription; import org.junit.jupiter.api.Test; import java.util.ArrayList; @@ -9,6 +11,7 @@ import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.not; +import static org.hamcrest.Matchers.equalTo; public class OnlyUniqueItemsTest { @Test @@ -20,4 +23,12 @@ public void onlyUniqueItemsTest() { list.add("a"); assertThat(list, not(onlyUniqueItems())); } + + @Test + public void describeToTest() { + OnlyUniqueItems onlyUniqueItems = new OnlyUniqueItems(); + Description description = new StringDescription(); + onlyUniqueItems.describeTo(description); + assertThat(description.toString(), equalTo("only unique items")); + } } diff --git a/src/test/java/edu/hawaii/its/api/wrapper/AssignAttributesResultsTest.java b/src/test/java/edu/hawaii/its/api/wrapper/AssignAttributesResultsTest.java index f762b6610..9d6725262 100644 --- a/src/test/java/edu/hawaii/its/api/wrapper/AssignAttributesResultsTest.java +++ b/src/test/java/edu/hawaii/its/api/wrapper/AssignAttributesResultsTest.java @@ -1,5 +1,8 @@ package edu.hawaii.its.api.wrapper; +import edu.internet2.middleware.grouperClient.ws.beans.WsAssignAttributeResult; +import edu.internet2.middleware.grouperClient.ws.beans.WsAttributeDefName; +import edu.internet2.middleware.grouperClient.ws.beans.WsGroup; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import edu.hawaii.its.api.util.JsonUtil; @@ -7,6 +10,7 @@ import edu.internet2.middleware.grouperClient.ws.beans.WsAssignAttributesResults; +import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -28,4 +32,47 @@ public void test() { assertNotNull(assignAttributesResults.getGroup()); assertNotNull(assignAttributesResults.getAttributesResults()); } + + @Test + public void constructorNullTest() { + AssignAttributesResults assignAttributesResults = new AssignAttributesResults(null); + assertNotNull(assignAttributesResults.getAssignAttributeResults()); + } + + @Test + public void emptyGroupTest() { + WsAssignAttributesResults wsAssignAttributesResults = new WsAssignAttributesResults(); + wsAssignAttributesResults.setWsGroups(new WsGroup[0]); + AssignAttributesResults results = new AssignAttributesResults(wsAssignAttributesResults); + assertNotNull(results.getGroup()); + } + + @Test + public void emptyAttributeResultsTest() { + WsAssignAttributesResults wsAssignAttributesResults = new WsAssignAttributesResults(); + AssignAttributesResults assignAttributesResults = new AssignAttributesResults(wsAssignAttributesResults); + assertNotNull(assignAttributesResults.getAssignAttributeResults()); + assertTrue(assignAttributesResults.getAssignAttributeResults().isEmpty()); + } + + @Test + public void attributeResultsTest() { + WsAssignAttributeResult wsAssignAttributeResult1 = new WsAssignAttributeResult(); + WsAssignAttributeResult wsAssignAttributeResult2 = new WsAssignAttributeResult(); + WsAssignAttributesResults wsAssignAttributesResults = new WsAssignAttributesResults(); + wsAssignAttributesResults.setWsAttributeAssignResults(new WsAssignAttributeResult[]{wsAssignAttributeResult1, wsAssignAttributeResult2}); + AssignAttributesResults assignAttributesResults = new AssignAttributesResults(wsAssignAttributesResults); + assertEquals(2, assignAttributesResults.getAssignAttributeResults().size()); + } + + @Test + public void attributeDefNamesTest() { + WsAttributeDefName wsAttributeDefName1 = new WsAttributeDefName(); + WsAttributeDefName wsAttributeDefName2 = new WsAttributeDefName(); + WsAssignAttributesResults wsAssignAttributesResults = new WsAssignAttributesResults(); + wsAssignAttributesResults.setWsAttributeDefNames(new WsAttributeDefName[]{wsAttributeDefName1, wsAttributeDefName2}); + AssignAttributesResults assignAttributesResults = new AssignAttributesResults(wsAssignAttributesResults); + assertEquals(2, assignAttributesResults.getAttributesResults().size()); + } + } diff --git a/src/test/java/edu/hawaii/its/api/wrapper/AttributeAssignValueResultTest.java b/src/test/java/edu/hawaii/its/api/wrapper/AttributeAssignValueResultTest.java new file mode 100644 index 000000000..842a51340 --- /dev/null +++ b/src/test/java/edu/hawaii/its/api/wrapper/AttributeAssignValueResultTest.java @@ -0,0 +1,88 @@ +package edu.hawaii.its.api.wrapper; + +import edu.internet2.middleware.grouperClient.ws.beans.WsAttributeAssignValue; +import edu.internet2.middleware.grouperClient.ws.beans.WsAttributeAssignValueResult; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +public class AttributeAssignValueResultTest { + @Test + public void constructorTest() { + AttributeAssignValueResult result = new AttributeAssignValueResult(); + assertNotNull(result.getValue()); + } + + @Test + public void constructorNullTest() { + AttributeAssignValueResult result = new AttributeAssignValueResult(null); + assertFalse(result.isValueChanged()); + assertFalse(result.isValueRemoved()); + assertEquals("", result.getValue()); + } + + @Test + public void constructorEmptyTest() { + WsAttributeAssignValueResult wsResult = new WsAttributeAssignValueResult(); + AttributeAssignValueResult result = new AttributeAssignValueResult(wsResult); + assertFalse(result.isValueChanged()); + assertFalse(result.isValueRemoved()); + assertEquals("", result.getValue()); + } + + @Test + public void isValueChangedTrueTest() { + WsAttributeAssignValueResult wsResult = new WsAttributeAssignValueResult(); + wsResult.setChanged("T"); + AttributeAssignValueResult result = new AttributeAssignValueResult(wsResult); + assertTrue(result.isValueChanged()); + } + + @Test + public void isValueChangedFalseTest() { + WsAttributeAssignValueResult wsResult = new WsAttributeAssignValueResult(); + wsResult.setChanged("F"); + AttributeAssignValueResult result = new AttributeAssignValueResult(wsResult); + assertFalse(result.isValueChanged()); + } + + @Test + public void isValueRemovedTrueTest() { + WsAttributeAssignValueResult wsResult = new WsAttributeAssignValueResult(); + wsResult.setDeleted("T"); + AttributeAssignValueResult result = new AttributeAssignValueResult(wsResult); + assertTrue(result.isValueRemoved()); + } + + @Test + public void isValueRemovedFalseTest() { + WsAttributeAssignValueResult wsResult = new WsAttributeAssignValueResult(); + wsResult.setDeleted("F"); + AttributeAssignValueResult result = new AttributeAssignValueResult(wsResult); + assertFalse(result.isValueRemoved()); + } + + @Test + public void getValueTest() { + WsAttributeAssignValue wsValue = new WsAttributeAssignValue(); + wsValue.setValueSystem("value"); + WsAttributeAssignValueResult wsResult = new WsAttributeAssignValueResult(); + wsResult.setWsAttributeAssignValue(wsValue); + AttributeAssignValueResult result = new AttributeAssignValueResult(wsResult); + assertEquals("value", result.getValue()); + } + + @Test + public void getValueNullTest() { + WsAttributeAssignValue wsValue = new WsAttributeAssignValue(); + wsValue.setValueSystem(null); + WsAttributeAssignValueResult wsResult = new WsAttributeAssignValueResult(); + wsResult.setWsAttributeAssignValue(wsValue); + AttributeAssignValueResult result = new AttributeAssignValueResult(wsResult); + assertEquals("", result.getValue()); + } + +} \ No newline at end of file diff --git a/src/test/java/edu/hawaii/its/api/wrapper/AttributesResultTest.java b/src/test/java/edu/hawaii/its/api/wrapper/AttributesResultTest.java index 91c678fd8..19ed79f5f 100644 --- a/src/test/java/edu/hawaii/its/api/wrapper/AttributesResultTest.java +++ b/src/test/java/edu/hawaii/its/api/wrapper/AttributesResultTest.java @@ -7,8 +7,7 @@ import edu.internet2.middleware.grouperClient.ws.beans.WsFindAttributeDefNamesResults; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.*; public class AttributesResultTest { private PropertyLocator propertyLocator; @@ -28,5 +27,11 @@ public void test() { assertNotNull(attributesResult); assertEquals("name", attributesResult.getName()); assertEquals("description", attributesResult.getDescription()); + + attributesResult = new AttributesResult(); + assertEquals("", attributesResult.getName()); + assertEquals("", attributesResult.getDescription()); + } + } diff --git a/src/test/java/edu/hawaii/its/api/wrapper/ResultsTest.java b/src/test/java/edu/hawaii/its/api/wrapper/ResultsTest.java index c4c093862..fc4c24230 100644 --- a/src/test/java/edu/hawaii/its/api/wrapper/ResultsTest.java +++ b/src/test/java/edu/hawaii/its/api/wrapper/ResultsTest.java @@ -4,7 +4,6 @@ import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; -import edu.hawaii.its.api.wrapper.Results; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -30,8 +29,17 @@ public void isEmpty() { assertThat(results.isEmpty(new Object[] { new Object() }), is(false)); } + @Test + public void getBoolean() { + assertThat(results.getBoolean(null), is(false)); + assertThat(results.getBoolean(""), is(false)); + assertThat(results.getBoolean("T"), is(true)); + assertThat(results.getBoolean("F"), is(false)); + } + @Test public void getResultCode() { assertThat(results.getResultCode(), equalTo("")); } + } diff --git a/src/test/java/edu/hawaii/its/api/wrapper/SubjectTest.java b/src/test/java/edu/hawaii/its/api/wrapper/SubjectTest.java index 901f29193..342df55af 100644 --- a/src/test/java/edu/hawaii/its/api/wrapper/SubjectTest.java +++ b/src/test/java/edu/hawaii/its/api/wrapper/SubjectTest.java @@ -16,6 +16,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; @ActiveProfiles("localTest") @SpringBootTest(classes = { SpringBootWebApplication.class }) @@ -124,4 +126,29 @@ public void accessors() { assertEquals("", subject.getLastName()); } + + @Test + public void hasUHAttributesTest() { + WsSubject wsSubject = new WsSubject(); + wsSubject.setAttributeValues(new String[]{"attribute"}); + Subject subject = new Subject(wsSubject); + assertTrue(subject.hasUHAttributes()); + } + + @Test + public void hasUHAttributesNullTest() { + WsSubject wsSubject = new WsSubject(); + wsSubject.setAttributeValues(null); + Subject subject = new Subject(wsSubject); + assertFalse(subject.hasUHAttributes()); + } + + @Test + public void hasUHAttributesEmptyTest() { + WsSubject wsSubject = new WsSubject(); + wsSubject.setAttributeValues(new String[]{""}); + Subject subject = new Subject(wsSubject); + assertFalse(subject.hasUHAttributes()); + } + } diff --git a/src/test/resources/grouper.test.properties b/src/test/resources/grouper.test.properties index 90dcca9f6..a0163a613 100644 --- a/src/test/resources/grouper.test.properties +++ b/src/test/resources/grouper.test.properties @@ -1,7 +1,5 @@ groupings.api.test.uh-usernames=testiwta,testiwtb,testiwtc,testiwtd,testiwte groupings.api.test.uh-numbers=99997010,99997027,99997033,99997043,99997056 -subject.not.found={"subjectAttributeNames": ["uid","cn","sn","givenName","uhUuid"],"wsSubjects": [{"resultCode": "SUBJECT_NOT_FOUND","success": "F","identifierLookup": null,"id": "22991362","name": null,"sourceId": null,"attributeValues": null } ],"resultMetadata": { "params": null,"resultCode": "SUCCESS","resultCode2": null,"success": "T","resultMessage": "Queried 1 subjects"},"responseMetadata": {"resultWarnings": ", Client version: 2.3.0 is less than (major/minor) server version: 2.2.2, Client version: 2.3.0 is less than (major/minor) server version: 2.2.2","millis": "12","serverVersion": "2.2.2"},"wsGroup": null} -subject.found={"subjectAttributeNames": ["uid","cn","sn","givenName","uhUuid"], "wsSubjects": [{"resultCode": "SUCCESS","success": "T","identifierLookup": "iamtst02","id": "iamtst02","name": "tst02name","sourceId": "UH core LDAP","attributeValues": ["iamtst02","tst02name","tst02name","tst02name","iamtst02"]}], "resultMetadata": { "params": null, "resultCode": "SUCCESS","resultCode2": null, "success": "T","resultMessage": "Queried 1 subjects" }, "responseMetadata": { "resultWarnings": ", Client version: 2.3.0 is less than (major/minor) server version: 2.2.2, Client version: 2.3.0 is less than (major/minor) server version: 2.2.2","millis": "3","serverVersion": "2.2.2"}, "wsGroup": null} attribute.assignment.opt.in.result={ "wsAttributeDefs": [ { "idIndex": "10021", "extension": "checkboxes", "description": null, "name": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "uuid": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefType": "attr", "multiAssignable": "F", "multiValued": "F", "valueType": "marker", "assignToAttributeDef": "F", "assignToAttributeDefAssignment": "F", "assignToEffectiveMembership": "F", "assignToEffectiveMembershipAssignment": "F", "assignToGroup": "F", "assignToGroupAssignment": "F", "assignToImmediateMembership": "F", "assignToImmediateMembershipAssignment": "F", "assignToMember": "F", "assignToMemberAssignment": "F", "assignToStem": "F", "assignToStemAssignment": "F" } ], "wsAttributeDefNames": [ { "idIndex": "10114", "extension": "opt-in", "displayExtension": "opt-in", "description": null, "displayName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:opt-in", "name": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:opt-in", "uuid": "7f56d32b05c64237bd285abda24d4187", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes" } ], "wsAttributeAssigns": [ { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": "bogus-def-name-name", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" }, { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": null, "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" }, { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:opt-in", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" } ], "subjectAttributeNames": null, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": ", Found 1 results. " }, "responseMetadata": { "resultWarnings": ", Client version: 2.3.0 is less than (major/minor) server version: 2.2.2, Client version: 2.3.0 is less than (major/minor) server version: 2.2.2", "millis": "196", "serverVersion": "2.2.2" }, "wsGroups": [ { "idIndex": "835554", "typeOfGroup": "group", "extension": "grouping-path-many", "displayExtension": "grouping-path-many", "description": "Test Many Groups In Basis", "displayName": "tmp:grouping-path:grouping-path-many", "name": "tmp:grouping-path:grouping-path-many", "uuid": "7bcea43fce194fa88e743e6ce70956a0", "detail": null } ], "wsStems": [], "wsMemberships": [], "wsSubjects": [] } attribute.assignment.opt.out.result={ "wsAttributeDefs": [ { "idIndex": "10021", "extension": "checkboxes", "description": null, "name": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "uuid": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefType": "attr", "multiAssignable": "F", "multiValued": "F", "valueType": "marker", "assignToAttributeDef": "F", "assignToAttributeDefAssignment": "F", "assignToEffectiveMembership": "F", "assignToEffectiveMembershipAssignment": "F", "assignToGroup": "F", "assignToGroupAssignment": "F", "assignToImmediateMembership": "F", "assignToImmediateMembershipAssignment": "F", "assignToMember": "F", "assignToMemberAssignment": "F", "assignToStem": "F", "assignToStemAssignment": "F" } ], "wsAttributeDefNames": [ { "idIndex": "10114", "extension": "opt-out", "displayExtension": "opt-out", "description": null, "displayName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:opt-out", "name": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:opt-out", "uuid": "7f56d32b05c64237bd285abda24d4187", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes" } ], "wsAttributeAssigns": [ { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": "bogus-def-name-name", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" }, { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": null, "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" }, { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:opt-out", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" } ], "subjectAttributeNames": null, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": ", Found 1 results. " }, "responseMetadata": { "resultWarnings": ", Client version: 2.3.0 is less than (major/minor) server version: 2.2.2, Client version: 2.3.0 is less than (major/minor) server version: 2.2.2", "millis": "196", "serverVersion": "2.2.2" }, "wsGroups": [ { "idIndex": "835554", "typeOfGroup": "group", "extension": "grouping-path-many", "displayExtension": "grouping-path-many", "description": "Test Many Groups In Basis", "displayName": "tmp:grouping-path:grouping-path-many", "name": "tmp:grouping-path:grouping-path-many", "uuid": "7bcea43fce194fa88e743e6ce70956a0", "detail": null } ], "wsStems": [], "wsMemberships": [], "wsSubjects": [] } attribute.assignment.empty.result={ "wsAttributeDefs": [ { "idIndex": "10021", "extension": "checkboxes", "description": null, "name": "", "uuid": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefType": "attr", "multiAssignable": "F", "multiValued": "F", "valueType": "marker", "assignToAttributeDef": "F", "assignToAttributeDefAssignment": "F", "assignToEffectiveMembership": "F", "assignToEffectiveMembershipAssignment": "F", "assignToGroup": "F", "assignToGroupAssignment": "F", "assignToImmediateMembership": "F", "assignToImmediateMembershipAssignment": "F", "assignToMember": "F", "assignToMemberAssignment": "F", "assignToStem": "F", "assignToStemAssignment": "F" } ], "wsAttributeDefNames": [ { "idIndex": "10114", "extension": "", "displayExtension": "", "description": null, "displayName": "", "name": "", "uuid": "7f56d32b05c64237bd285abda24d4187", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "" } ], "wsAttributeAssigns": [ { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": "bogus-def-name-name", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" }, { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": null, "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" }, { "attributeAssignActionType": "immediate", "attributeAssignDelegatable": "FALSE", "attributeAssignActionId": "2eca81d617454320a414c78cda674a4e", "attributeAssignActionName": "assign", "attributeAssignType": "group", "attributeDefNameId": "7f56d32b05c64237bd285abda24d4187", "attributeDefNameName": "", "attributeDefId": "c00c8544d5cf419ab3ff8e6c94f44209", "attributeDefName": "uh-settings:attributes:for-groups:uh-grouping:anyone-can:checkboxes", "wsAttributeAssignValues": null, "createdOn": "2022/06/27 20:04:20.576", "disabledTime": null, "enabled": "T", "enabledTime": null, "id": "5ecc2ff1ef4e4e90bfadc033634c6d8c", "lastUpdated": "2022/06/27 20:04:20.576", "notes": null, "ownerAttributeAssignId": null, "ownerAttributeDefId": null, "ownerAttributeDefName": null, "ownerGroupId": "7bcea43fce194fa88e743e6ce70956a0", "ownerGroupName": "tmp:grouping-path:grouping-path-many", "ownerMemberId": null, "ownerMemberSubjectId": null, "ownerMemberSourceId": null, "ownerMembershipId": null, "ownerStemId": null, "ownerStemName": null, "disallowed": "F" } ], "subjectAttributeNames": null, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": ", Found 1 results. " }, "responseMetadata": { "resultWarnings": ", Client version: 2.3.0 is less than (major/minor) server version: 2.2.2, Client version: 2.3.0 is less than (major/minor) server version: 2.2.2", "millis": "196", "serverVersion": "2.2.2" }, "wsGroups": [ { "idIndex": "835554", "typeOfGroup": "group", "extension": "grouping-path-many", "displayExtension": "grouping-path-many", "description": "Test Many Groups In Basis", "displayName": "tmp:grouping-path:grouping-path-many", "name": "tmp:grouping-path:grouping-path-many", "uuid": "7bcea43fce194fa88e743e6ce70956a0", "detail": null } ], "wsStems": [], "wsMemberships": [], "wsSubjects": [] } @@ -37,7 +35,7 @@ ws.add.member.results.success.owners.timestamp= { "groupPath" : "tmp:testiwta:te ws.delete.member.results.failure={ "results": [ { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwta", "id": "99997010", "name": "Testf-iwt-a TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwta", "Testf-iwt-a TestIAM-staff", "TestIAM-staff", "Testf-iwt-a", "", "eduPersonOrgDN=uhsystem,eduPersonAffiliation=staff", "staff", "uhsystem", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtb", "id": "99997027", "name": "Testf-iwt-b TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtb", "Testf-iwt-b TestIAM-staff", "TestIAM-staff", "Testf-iwt-b", "", "eduPersonOrgDN=uhm,eduPersonAffiliation=staff", "staff", "uhm", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtc", "id": "99997033", "name": "Testf-iwt-c TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtc", "Testf-iwt-c TestIAM-staff", "TestIAM-staff", "Testf-iwt-c", "", "eduPersonOrgDN=rcuh,eduPersonAffiliation=staff", "staff", "rcuh", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtd", "id": "99997043", "name": "Testf-iwt-d TestIAM-faculty", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtd", "Testf-iwt-d TestIAM-faculty", "TestIAM-faculty", "Testf-iwt-d", "", "eduPersonOrgDN=kcc,eduPersonAffiliation=faculty", "faculty", "kcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwte", "id": "99997056", "name": "Testf-iwt-e TestIAM-student", "sourceId": "UH core LDAP", "attributeValues": [ "testiwte", "Testf-iwt-e TestIAM-student", "TestIAM-student", "Testf-iwt-e", "", "eduPersonOrgDN=lcc,eduPersonAffiliation=student", "student", "lcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } } ], "wsGroup": { "idIndex": "835551", "typeOfGroup": "group", "extension": "include", "displayExtension": "include", "description": null, "displayName": "group-path", "name": "group-path", "uuid": "9c3378e64b39459ab0a0a7f3aa03c8ba", "detail": null }, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": "" }, "responseMetadata": { "resultWarnings": "", "millis": "181", "serverVersion": "2.2.2" }, "subjectAttributeNames": [ "uid", "cn", "sn", "givenName", "displayName", "uhOrgAffiliation", "eduPersonAffiliation", "eduPersonOrgDN", "uhScopedHomeOrg" ] } ws.delete.member.results.success={ "results": [ { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwta", "id": "99997010", "name": "Testf-iwt-a TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwta", "Testf-iwt-a TestIAM-staff", "TestIAM-staff", "Testf-iwt-a", "", "eduPersonOrgDN=uhsystem,eduPersonAffiliation=staff", "staff", "uhsystem", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtb", "id": "99997027", "name": "Testf-iwt-b TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtb", "Testf-iwt-b TestIAM-staff", "TestIAM-staff", "Testf-iwt-b", "", "eduPersonOrgDN=uhm,eduPersonAffiliation=staff", "staff", "uhm", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtc", "id": "99997033", "name": "Testf-iwt-c TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtc", "Testf-iwt-c TestIAM-staff", "TestIAM-staff", "Testf-iwt-c", "", "eduPersonOrgDN=rcuh,eduPersonAffiliation=staff", "staff", "rcuh", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtd", "id": "99997043", "name": "Testf-iwt-d TestIAM-faculty", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtd", "Testf-iwt-d TestIAM-faculty", "TestIAM-faculty", "Testf-iwt-d", "", "eduPersonOrgDN=kcc,eduPersonAffiliation=faculty", "faculty", "kcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwte", "id": "99997056", "name": "Testf-iwt-e TestIAM-student", "sourceId": "UH core LDAP", "attributeValues": [ "testiwte", "Testf-iwt-e TestIAM-student", "TestIAM-student", "Testf-iwt-e", "", "eduPersonOrgDN=lcc,eduPersonAffiliation=student", "student", "lcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "SUCCESS_WASNT_IMMEDIATE", "resultCode2": null, "success": "T", "resultMessage": null } } ], "wsGroup": { "idIndex": "835551", "typeOfGroup": "group", "extension": "include", "displayExtension": "include", "description": null, "displayName": "group-path", "name": "group-path", "uuid": "9c3378e64b39459ab0a0a7f3aa03c8ba", "detail": null }, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": "" }, "responseMetadata": { "resultWarnings": "", "millis": "181", "serverVersion": "2.2.2" }, "subjectAttributeNames": [ "uid", "cn", "sn", "givenName", "displayName", "uhOrgAffiliation", "eduPersonAffiliation", "eduPersonOrgDN", "uhScopedHomeOrg" ] } -ws.has.member.results.is.members.uhuuid={ "results": [ { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997010", "name": "Testf-iwt-a TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwta", "Testf-iwt-a TestIAM-staff", "TestIAM-staff", "Testf-iwt-a", "eduPersonOrgDN=uhsystem,eduPersonAffiliation=staff", "staff", "uhsystem", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997027", "name": "Testf-iwt-b TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtb", "Testf-iwt-b TestIAM-staff", "TestIAM-staff", "Testf-iwt-b", "eduPersonOrgDN=uhm,eduPersonAffiliation=staff", "staff", "uhm", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997033", "name": "Testf-iwt-c TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtc", "Testf-iwt-c TestIAM-staff", "TestIAM-staff", "Testf-iwt-c", "eduPersonOrgDN=rcuh,eduPersonAffiliation=staff", "staff", "rcuh", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997043", "name": "Testf-iwt-d TestIAM-faculty", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtd", "Testf-iwt-d TestIAM-faculty", "TestIAM-faculty", "Testf-iwt-d", "eduPersonOrgDN=kcc,eduPersonAffiliation=faculty", "faculty", "kcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997056", "name": "Testf-iwt-e TestIAM-student", "sourceId": "UH core LDAP", "attributeValues": [ "testiwte", "Testf-iwt-e TestIAM-student", "TestIAM-student", "Testf-iwt-e", "eduPersonOrgDN=lcc,eduPersonAffiliation=student", "student", "lcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } } ], "wsGroup": { "idIndex": "835551", "typeOfGroup": "group", "extension": "include", "displayExtension": "include", "description": null, "displayName": "tmp:gilbertz:gilbertz-many:include", "name": "group-path", "uuid": "9c3378e64b39459ab0a0a7f3aa03c8ba", "detail": null }, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": "" }, "subjectAttributeNames": [ "uid", "cn", "sn", "givenName", "uhOrgAffiliation", "eduPersonAffiliation", "eduPersonOrgDN", "uhScopedHomeOrg" ], "responseMetadata": { "resultWarnings": "", "millis": "371", "serverVersion": "2.2.2" } } +ws.has.member.results.is.members.uhuuid={ "results": [ { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997010", "name": "Testf-iwt-a TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwta", "Testf-iwt-a TestIAM-staff", "TestIAM-staff", "Testf-iwt-a", "eduPersonOrgDN=uhsystem,eduPersonAffiliation=staff", "staff", "uhsystem", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997027", "name": "Testf-iwt-b TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtb", "Testf-iwt-b TestIAM-staff", "TestIAM-staff", "Testf-iwt-b", "eduPersonOrgDN=uhm,eduPersonAffiliation=staff", "staff", "uhm", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997033", "name": "Testf-iwt-c TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtc", "Testf-iwt-c TestIAM-staff", "TestIAM-staff", "Testf-iwt-c", "eduPersonOrgDN=rcuh,eduPersonAffiliation=staff", "staff", "rcuh", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997043", "name": "Testf-iwt-d TestIAM-faculty", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtd", "Testf-iwt-d TestIAM-faculty", "TestIAM-faculty", "Testf-iwt-d", "eduPersonOrgDN=kcc,eduPersonAffiliation=faculty", "faculty", "kcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": null, "id": "99997056", "name": "Testf-iwt-e TestIAM-student", "sourceId": "UH core LDAP", "attributeValues": [ "testiwte", "Testf-iwt-e TestIAM-student", "TestIAM-student", "Testf-iwt-e", "eduPersonOrgDN=lcc,eduPersonAffiliation=student", "student", "lcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } } ], "wsGroup": { "idIndex": "835551", "typeOfGroup": "group", "extension": "include", "displayExtension": "include", "description": null, "displayName": "tmp:testiwta:testiwta-many:include", "name": "group-path", "uuid": "9c3378e64b39459ab0a0a7f3aa03c8ba", "detail": null }, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": "" }, "subjectAttributeNames": [ "uid", "cn", "sn", "givenName", "uhOrgAffiliation", "eduPersonAffiliation", "eduPersonOrgDN", "uhScopedHomeOrg" ], "responseMetadata": { "resultWarnings": "", "millis": "371", "serverVersion": "2.2.2" } } ws.has.member.results.is.members.uid={ "results": [ { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwta", "id": "99997010", "name": "Testf-iwt-a TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwta", "Testf-iwt-a TestIAM-staff", "TestIAM-staff", "Testf-iwt-a", "eduPersonOrgDN=uhsystem,eduPersonAffiliation=staff", "staff", "uhsystem", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtb", "id": "99997027", "name": "Testf-iwt-b TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtb", "Testf-iwt-b TestIAM-staff", "TestIAM-staff", "Testf-iwt-b", "eduPersonOrgDN=uhm,eduPersonAffiliation=staff", "staff", "uhm", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtc", "id": "99997033", "name": "Testf-iwt-c TestIAM-staff", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtc", "Testf-iwt-c TestIAM-staff", "TestIAM-staff", "Testf-iwt-c", "eduPersonOrgDN=rcuh,eduPersonAffiliation=staff", "staff", "rcuh", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwtd", "id": "99997043", "name": "Testf-iwt-d TestIAM-faculty", "sourceId": "UH core LDAP", "attributeValues": [ "testiwtd", "Testf-iwt-d TestIAM-faculty", "TestIAM-faculty", "Testf-iwt-d", "eduPersonOrgDN=kcc,eduPersonAffiliation=faculty", "faculty", "kcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } }, { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "testiwte", "id": "99997056", "name": "Testf-iwt-e TestIAM-student", "sourceId": "UH core LDAP", "attributeValues": [ "testiwte", "Testf-iwt-e TestIAM-student", "TestIAM-student", "Testf-iwt-e", "eduPersonOrgDN=lcc,eduPersonAffiliation=student", "student", "lcc", "" ] }, "resultMetadata": { "params": null, "resultCode": "IS_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } } ], "wsGroup": { "idIndex": "835551", "typeOfGroup": "group", "extension": "include", "displayExtension": "include", "description": null, "displayName": "tmp:gilbertz:gilbertz-many:include", "name": "tmp:gilbertz:gilbertz-many:include", "uuid": "9c3378e64b39459ab0a0a7f3aa03c8ba", "detail": null }, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": "" }, "subjectAttributeNames": [ "uid", "cn", "sn", "givenName", "uhOrgAffiliation", "eduPersonAffiliation", "eduPersonOrgDN", "uhScopedHomeOrg" ], "responseMetadata": { "resultWarnings": "", "millis": "68", "serverVersion": "2.2.2" } } ws.has.member.results.is.members.failure={ "results": [], "wsGroup": { "idIndex": "835551", "typeOfGroup": "group", "extension": "", "displayExtension": null, "description": null, "displayName": null, "name": null, "uuid": null, "detail": null }, "resultMetadata": { "params": null, "resultCode": "FAILURE", "resultCode2": null, "success": "T", "resultMessage": "" }, "responseMetadata": { "resultWarnings": "", "millis": "371", "serverVersion": "2.2.2" } } ws.has.member.results.is.not.members={ "results": [ { "wsSubject": { "resultCode": "SUCCESS", "success": "T", "identifierLookup": "uid", "id": "uhUuid", "name": "name", "sourceId": "UH core LDAP", "attributeValues": null }, "resultMetadata": { "params": null, "resultCode": "IS_NOT_MEMBER", "resultCode2": null, "success": "T", "resultMessage": null } } ], "wsGroup": { "idIndex": "835551", "typeOfGroup": "group", "extension": "include", "displayExtension": "include", "description": null, "displayName": "group-path", "name": "group-path", "uuid": "9c3378e64b39459ab0a0a7f3aa03c8ba", "detail": null }, "resultMetadata": { "params": null, "resultCode": "SUCCESS", "resultCode2": null, "success": "T", "resultMessage": "" }, "subjectAttributeNames": null, "responseMetadata": { "resultWarnings": "", "millis": "221", "serverVersion": "2.2.2" } }