FrankChen021 commented on code in PR #19877:
URL: https://github.com/apache/druid/pull/19877#discussion_r3714393572
##########
extensions-core/druid-basic-security/src/test/java/org/apache/druid/security/basic/authorization/endpoint/BasicAuthorizerResourceTest.java:
##########
@@ -74,264 +79,286 @@
@Test
public void getAllUsersShouldReturnExpectedUsers()
{
- Assert.assertNotNull(target.getAllUsers(req, AUTHORIZER_NAME));
+ Assertions.assertNotNull(target.getAllUsers(req, AUTHORIZER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getAllUsersWithInvalidAuthorizerNameShouldThrowException()
{
- target.getAllUsers(req, INVALID_AUTHORIZER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getAllUsers(req, INVALID_AUTHORIZER_NAME));
}
@Test
public void getAllGroupMappingsShouldReturnExpectedGroupMappings()
{
- Assert.assertNotNull(target.getAllGroupMappings(req, AUTHORIZER_NAME));
+ Assertions.assertNotNull(target.getAllGroupMappings(req, AUTHORIZER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
getAllGroupMappingsWithInvalidAuthorizerNameShouldThrowException()
{
- target.getAllGroupMappings(req, INVALID_AUTHORIZER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getAllGroupMappings(req, INVALID_AUTHORIZER_NAME));
}
@Test
public void getUserShouldReturnExpectedUser()
{
- Assert.assertNotNull(target.getUser(req, AUTHORIZER_NAME, USER_NAME, null,
null));
+ Assertions.assertNotNull(target.getUser(req, AUTHORIZER_NAME, USER_NAME,
null, null));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.getUser(req, INVALID_AUTHORIZER_NAME, USER_NAME, null, null);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getUser(req, INVALID_AUTHORIZER_NAME, USER_NAME, null, null));
}
@Test
public void getGroupMappingShouldReturnExpectedGroupMapping()
{
- Assert.assertNotNull(target.getGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, null));
+ Assertions.assertNotNull(target.getGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, null));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.getGroupMapping(req, INVALID_AUTHORIZER_NAME, GROUP_MAPPING_NAME,
null);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getGroupMapping(req, INVALID_AUTHORIZER_NAME, GROUP_MAPPING_NAME,
null));
}
@Test
public void createUserShouldReturnExpectedResponse()
{
- Assert.assertNotNull(target.createUser(req, AUTHORIZER_NAME, USER_NAME));
+ Assertions.assertNotNull(target.createUser(req, AUTHORIZER_NAME,
USER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void createUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.createUser(req, INVALID_AUTHORIZER_NAME, USER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.createUser(req, INVALID_AUTHORIZER_NAME, USER_NAME));
}
@Test
public void deleteUserShouldReturnExpectedResponse()
{
- Assert.assertNotNull(target.deleteUser(req, AUTHORIZER_NAME, USER_NAME));
+ Assertions.assertNotNull(target.deleteUser(req, AUTHORIZER_NAME,
USER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void deleteUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.deleteUser(req, INVALID_AUTHORIZER_NAME, USER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.deleteUser(req, INVALID_AUTHORIZER_NAME, USER_NAME));
}
@Test
public void createGroupMappingShouldReturnExpectedResponse()
{
- Assert.assertNotNull(target.createGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, groupMapping));
+ Assertions.assertNotNull(target.createGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, groupMapping));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void createGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.createGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, groupMapping);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.createGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, groupMapping));
}
@Test
public void deleteGroupMappingShouldReturnExpectedResponse()
{
- Assert.assertNotNull(target.deleteGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME));
+ Assertions.assertNotNull(target.deleteGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void deleteGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.deleteGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.deleteGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME));
}
@Test
public void getRoleShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.getRole(req, AUTHORIZER_NAME, ROLE_NAME, null,
null));
+ Assertions.assertNotNull(target.getRole(req, AUTHORIZER_NAME, ROLE_NAME,
null, null));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getRoleWithInvalidAuthorizerNameShouldThrowException()
{
- target.getRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME, null, null);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME, null, null));
}
@Test
public void createRoleShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.createRole(req, AUTHORIZER_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.createRole(req, AUTHORIZER_NAME,
ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void createRoleWithInvalidAuthorizerNameShouldThrowException()
{
- target.createRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.createRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME));
}
@Test
public void deleteRoleShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.deleteRole(req, AUTHORIZER_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.deleteRole(req, AUTHORIZER_NAME,
ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void deleteRoleWithInvalidAuthorizerNameShouldThrowException()
{
- target.deleteRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.deleteRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME));
}
@Test
public void assignRoleToUserShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.assignRoleToUser(req, AUTHORIZER_NAME,
USER_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.assignRoleToUser(req, AUTHORIZER_NAME,
USER_NAME, ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void assignRoleToUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.assignRoleToUser(req, INVALID_AUTHORIZER_NAME, USER_NAME,
ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.assignRoleToUser(req, INVALID_AUTHORIZER_NAME, USER_NAME,
ROLE_NAME));
}
@Test
public void unassignRoleFromUserShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.unassignRoleFromUser(req, AUTHORIZER_NAME,
USER_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.unassignRoleFromUser(req, AUTHORIZER_NAME,
USER_NAME, ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
unassignRoleFromUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.unassignRoleFromUser(req, INVALID_AUTHORIZER_NAME, USER_NAME,
ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.unassignRoleFromUser(req, INVALID_AUTHORIZER_NAME, USER_NAME,
ROLE_NAME));
}
@Test
public void assignRoleToGroupMappingShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.assignRoleToGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.assignRoleToGroupMapping(req,
AUTHORIZER_NAME, GROUP_MAPPING_NAME, ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
assignRoleToGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.assignRoleToGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.assignRoleToGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME));
}
@Test
public void unassignRoleFromGroupMappingShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.unassignRoleFromGroupMapping(req,
AUTHORIZER_NAME, GROUP_MAPPING_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.unassignRoleFromGroupMapping(req,
AUTHORIZER_NAME, GROUP_MAPPING_NAME, ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
unassignRoleFromGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.unassignRoleFromGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.unassignRoleFromGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME));
}
@Test
public void setRolePermissionsShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.setRolePermissions(req, AUTHORIZER_NAME,
ROLE_NAME, resourceActions));
+ Assertions.assertNotNull(target.setRolePermissions(req, AUTHORIZER_NAME,
ROLE_NAME, resourceActions));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void setRolePermissionsWithInvalidAuthorizerNameShouldThrowException()
{
- target.setRolePermissions(req, INVALID_AUTHORIZER_NAME, ROLE_NAME,
resourceActions);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.setRolePermissions(req, INVALID_AUTHORIZER_NAME, ROLE_NAME,
resourceActions));
}
@Test
public void getRolePermissionsShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.getRolePermissions(req, AUTHORIZER_NAME,
ROLE_NAME));
+ Assertions.assertNotNull(target.getRolePermissions(req, AUTHORIZER_NAME,
ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getRolePermissionsWithInvalidAuthorizerNameShouldThrowException()
{
- target.getRolePermissions(req, INVALID_AUTHORIZER_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getRolePermissions(req, INVALID_AUTHORIZER_NAME, ROLE_NAME));
}
@Test
public void getCachedSerializedUserMapShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.getCachedSerializedUserMap(req,
AUTHORIZER_NAME));
+ Assertions.assertNotNull(target.getCachedSerializedUserMap(req,
AUTHORIZER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
getCachedSerializedUserMapWithInvalidAuthorizerNameShouldThrowException()
{
- target.getCachedSerializedUserMap(req, INVALID_AUTHORIZER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getCachedSerializedUserMap(req, INVALID_AUTHORIZER_NAME));
}
@Test
public void getCachedSerializedGroupMapShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.getCachedSerializedGroupMap(req,
AUTHORIZER_NAME));
+ Assertions.assertNotNull(target.getCachedSerializedGroupMap(req,
AUTHORIZER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
getCachedSerializedGroupMapWithInvalidAuthorizerNameShouldThrowException()
{
- target.getCachedSerializedGroupMap(req, INVALID_AUTHORIZER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getCachedSerializedGroupMap(req, INVALID_AUTHORIZER_NAME));
}
@Test
public void authorizerUpdateListenerShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.authorizerUpdateListener(req, AUTHORIZER_NAME,
SERIALIZED_ROLE_MAP));
+ Assertions.assertNotNull(target.authorizerUpdateListener(req,
AUTHORIZER_NAME, SERIALIZED_ROLE_MAP));
Review Comment:
Thanks for flagging this. The deprecated
`BasicAuthorizerResource.authorizerUpdateListener` call is already present on
`master`; this PR only changes the surrounding JUnit assertions and exception
handling. I’m leaving the existing API-deprecation cleanup out of this JUnit
migration and will track it separately.
##########
extensions-core/druid-basic-security/src/test/java/org/apache/druid/security/basic/authorization/endpoint/BasicAuthorizerResourceTest.java:
##########
@@ -74,264 +79,286 @@
@Test
public void getAllUsersShouldReturnExpectedUsers()
{
- Assert.assertNotNull(target.getAllUsers(req, AUTHORIZER_NAME));
+ Assertions.assertNotNull(target.getAllUsers(req, AUTHORIZER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getAllUsersWithInvalidAuthorizerNameShouldThrowException()
{
- target.getAllUsers(req, INVALID_AUTHORIZER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getAllUsers(req, INVALID_AUTHORIZER_NAME));
}
@Test
public void getAllGroupMappingsShouldReturnExpectedGroupMappings()
{
- Assert.assertNotNull(target.getAllGroupMappings(req, AUTHORIZER_NAME));
+ Assertions.assertNotNull(target.getAllGroupMappings(req, AUTHORIZER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
getAllGroupMappingsWithInvalidAuthorizerNameShouldThrowException()
{
- target.getAllGroupMappings(req, INVALID_AUTHORIZER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getAllGroupMappings(req, INVALID_AUTHORIZER_NAME));
}
@Test
public void getUserShouldReturnExpectedUser()
{
- Assert.assertNotNull(target.getUser(req, AUTHORIZER_NAME, USER_NAME, null,
null));
+ Assertions.assertNotNull(target.getUser(req, AUTHORIZER_NAME, USER_NAME,
null, null));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.getUser(req, INVALID_AUTHORIZER_NAME, USER_NAME, null, null);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getUser(req, INVALID_AUTHORIZER_NAME, USER_NAME, null, null));
}
@Test
public void getGroupMappingShouldReturnExpectedGroupMapping()
{
- Assert.assertNotNull(target.getGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, null));
+ Assertions.assertNotNull(target.getGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, null));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.getGroupMapping(req, INVALID_AUTHORIZER_NAME, GROUP_MAPPING_NAME,
null);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getGroupMapping(req, INVALID_AUTHORIZER_NAME, GROUP_MAPPING_NAME,
null));
}
@Test
public void createUserShouldReturnExpectedResponse()
{
- Assert.assertNotNull(target.createUser(req, AUTHORIZER_NAME, USER_NAME));
+ Assertions.assertNotNull(target.createUser(req, AUTHORIZER_NAME,
USER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void createUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.createUser(req, INVALID_AUTHORIZER_NAME, USER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.createUser(req, INVALID_AUTHORIZER_NAME, USER_NAME));
}
@Test
public void deleteUserShouldReturnExpectedResponse()
{
- Assert.assertNotNull(target.deleteUser(req, AUTHORIZER_NAME, USER_NAME));
+ Assertions.assertNotNull(target.deleteUser(req, AUTHORIZER_NAME,
USER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void deleteUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.deleteUser(req, INVALID_AUTHORIZER_NAME, USER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.deleteUser(req, INVALID_AUTHORIZER_NAME, USER_NAME));
}
@Test
public void createGroupMappingShouldReturnExpectedResponse()
{
- Assert.assertNotNull(target.createGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, groupMapping));
+ Assertions.assertNotNull(target.createGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, groupMapping));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void createGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.createGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, groupMapping);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.createGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, groupMapping));
}
@Test
public void deleteGroupMappingShouldReturnExpectedResponse()
{
- Assert.assertNotNull(target.deleteGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME));
+ Assertions.assertNotNull(target.deleteGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void deleteGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.deleteGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.deleteGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME));
}
@Test
public void getRoleShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.getRole(req, AUTHORIZER_NAME, ROLE_NAME, null,
null));
+ Assertions.assertNotNull(target.getRole(req, AUTHORIZER_NAME, ROLE_NAME,
null, null));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getRoleWithInvalidAuthorizerNameShouldThrowException()
{
- target.getRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME, null, null);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME, null, null));
}
@Test
public void createRoleShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.createRole(req, AUTHORIZER_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.createRole(req, AUTHORIZER_NAME,
ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void createRoleWithInvalidAuthorizerNameShouldThrowException()
{
- target.createRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.createRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME));
}
@Test
public void deleteRoleShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.deleteRole(req, AUTHORIZER_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.deleteRole(req, AUTHORIZER_NAME,
ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void deleteRoleWithInvalidAuthorizerNameShouldThrowException()
{
- target.deleteRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.deleteRole(req, INVALID_AUTHORIZER_NAME, ROLE_NAME));
}
@Test
public void assignRoleToUserShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.assignRoleToUser(req, AUTHORIZER_NAME,
USER_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.assignRoleToUser(req, AUTHORIZER_NAME,
USER_NAME, ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void assignRoleToUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.assignRoleToUser(req, INVALID_AUTHORIZER_NAME, USER_NAME,
ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.assignRoleToUser(req, INVALID_AUTHORIZER_NAME, USER_NAME,
ROLE_NAME));
}
@Test
public void unassignRoleFromUserShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.unassignRoleFromUser(req, AUTHORIZER_NAME,
USER_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.unassignRoleFromUser(req, AUTHORIZER_NAME,
USER_NAME, ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
unassignRoleFromUserWithInvalidAuthorizerNameShouldThrowException()
{
- target.unassignRoleFromUser(req, INVALID_AUTHORIZER_NAME, USER_NAME,
ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.unassignRoleFromUser(req, INVALID_AUTHORIZER_NAME, USER_NAME,
ROLE_NAME));
}
@Test
public void assignRoleToGroupMappingShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.assignRoleToGroupMapping(req, AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.assignRoleToGroupMapping(req,
AUTHORIZER_NAME, GROUP_MAPPING_NAME, ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
assignRoleToGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.assignRoleToGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.assignRoleToGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME));
}
@Test
public void unassignRoleFromGroupMappingShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.unassignRoleFromGroupMapping(req,
AUTHORIZER_NAME, GROUP_MAPPING_NAME, ROLE_NAME));
+ Assertions.assertNotNull(target.unassignRoleFromGroupMapping(req,
AUTHORIZER_NAME, GROUP_MAPPING_NAME, ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
unassignRoleFromGroupMappingWithInvalidAuthorizerNameShouldThrowException()
{
- target.unassignRoleFromGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.unassignRoleFromGroupMapping(req, INVALID_AUTHORIZER_NAME,
GROUP_MAPPING_NAME, ROLE_NAME));
}
@Test
public void setRolePermissionsShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.setRolePermissions(req, AUTHORIZER_NAME,
ROLE_NAME, resourceActions));
+ Assertions.assertNotNull(target.setRolePermissions(req, AUTHORIZER_NAME,
ROLE_NAME, resourceActions));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void setRolePermissionsWithInvalidAuthorizerNameShouldThrowException()
{
- target.setRolePermissions(req, INVALID_AUTHORIZER_NAME, ROLE_NAME,
resourceActions);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.setRolePermissions(req, INVALID_AUTHORIZER_NAME, ROLE_NAME,
resourceActions));
}
@Test
public void getRolePermissionsShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.getRolePermissions(req, AUTHORIZER_NAME,
ROLE_NAME));
+ Assertions.assertNotNull(target.getRolePermissions(req, AUTHORIZER_NAME,
ROLE_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void getRolePermissionsWithInvalidAuthorizerNameShouldThrowException()
{
- target.getRolePermissions(req, INVALID_AUTHORIZER_NAME, ROLE_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getRolePermissions(req, INVALID_AUTHORIZER_NAME, ROLE_NAME));
}
@Test
public void getCachedSerializedUserMapShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.getCachedSerializedUserMap(req,
AUTHORIZER_NAME));
+ Assertions.assertNotNull(target.getCachedSerializedUserMap(req,
AUTHORIZER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
getCachedSerializedUserMapWithInvalidAuthorizerNameShouldThrowException()
{
- target.getCachedSerializedUserMap(req, INVALID_AUTHORIZER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getCachedSerializedUserMap(req, INVALID_AUTHORIZER_NAME));
}
@Test
public void getCachedSerializedGroupMapShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.getCachedSerializedGroupMap(req,
AUTHORIZER_NAME));
+ Assertions.assertNotNull(target.getCachedSerializedGroupMap(req,
AUTHORIZER_NAME));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
getCachedSerializedGroupMapWithInvalidAuthorizerNameShouldThrowException()
{
- target.getCachedSerializedGroupMap(req, INVALID_AUTHORIZER_NAME);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.getCachedSerializedGroupMap(req, INVALID_AUTHORIZER_NAME));
}
@Test
public void authorizerUpdateListenerShouldReturnExpectedResult()
{
- Assert.assertNotNull(target.authorizerUpdateListener(req, AUTHORIZER_NAME,
SERIALIZED_ROLE_MAP));
+ Assertions.assertNotNull(target.authorizerUpdateListener(req,
AUTHORIZER_NAME, SERIALIZED_ROLE_MAP));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void
authorizerUpdateListenerWithInvalidAuthorizerNameShouldThrowException()
{
- target.authorizerUpdateListener(req, INVALID_AUTHORIZER_NAME,
SERIALIZED_ROLE_MAP);
+ assertThrows(IllegalArgumentException.class, () ->
+ target.authorizerUpdateListener(req, INVALID_AUTHORIZER_NAME,
SERIALIZED_ROLE_MAP));
Review Comment:
Thanks for flagging this. The deprecated
`BasicAuthorizerResource.authorizerUpdateListener` call is already present on
`master`; this PR only changes the surrounding JUnit assertions and exception
handling. I’m leaving the existing API-deprecation cleanup out of this JUnit
migration and will track it separately.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
