def normal_test_level_3_2(self):
'''
是否实现：是
测试意图：管理员修改自己密码
测试步骤：1、管理员用户admin 修改自己的密码，应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.set_pwd("admin", "aaaaa", "aaaaa"))
# 恢复环境
self.environment.refresh_root_session("aaaaa")
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.set_pwd("admin", "admin", "admin"))
self.environment.refresh_root_session("admin")
def normal_test_level_3_8(self):
'''
是否实现：是
测试意图：管理员禁用默认管理员admin
测试步骤：1、管理员用户admin 创建一个管理员帐号A
2、登录帐号A，然后禁用admin,应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
A_session = user.login(self.environment.server, "A", "test")
A_user = user.user(self.config_para.server_addr, A_session)
self.assertFalse(A_user.set_enable_disable("admin", user.USER_DISABLE))
# 恢复环境
self.assertTrue(u.delete("A"))
def auth_test_level_3_3(self):
'''
是否实现：是
测试意图：测试租户权限下，修改自己的角色信息
测试步骤：1、创建一个普通租户帐号A
2、登录A帐号，使用设置接口，修改自己的角色信息，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
A_seesion = user.login(self.environment.server, "A", "test")
A_user = user.user(self.config_para.server_addr, A_seesion)
self.assertFalse(A_user.set_role("A", user.CLOUDADMIN))
# 恢复环境
self.assertTrue(u.delete("A"))
def auth_test_level_3_2(self):
'''
是否实现：是
测试意图：测试普通租户权限下面的操作
测试步骤：1、使用租户A创建一个租户B，应该失败
'''
root_u = user.user(self.config_para.server_addr, self.environment.get_root_session())
name = "A"
self.assertTrue(root_u.allocate(name, "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
normal_session = user.login(self.environment.server, name, "test")
normal_u = user.user(self.config_para.server_addr, normal_session)
self.assertFalse(normal_u.allocate("B", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
#还原测试环境
self.assertTrue(root_u.delete(name))
def Exception_test_level_3_1(self):
'''
是否实现：是
测试意图：测试是否可以删除自己的帐号
测试步骤：1、创建另一个管理员帐号A
2、用A帐号登录，然后删除自己，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.CLOUDADMIN, self.config_para.test_usergroup))
A_session = user.login(self.environment.server, "A", "test")
A_user = user.user(self.config_para.server_addr, A_session)
self.assertFalse(A_user.delete("A"))
# 恢复环境
self.assertTrue(u.delete("A"))
def normal_test_level_3_3(self):
'''
是否实现：是
测试意图：测试密码和确认密码不通的流程
测试步骤：1、在用户组cigroup下面，增加一个普通租户帐号，用户名为A，密码和确认密码不同，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertFalse(u.allocate("A", "test", "test1", user.ACCOUNTUSER, self.config_para.test_usergroup))
def normal_test_level_3_3(self):
'''
是否实现：是
测试意图：管理员修改自己的角色
测试步骤：1、管理员用户admin 修改自己的角色为普通用户，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertFalse(u.set_role("admin", user.ACCOUNTUSER))
def normal_test_level_3_2(self):
'''
是否实现：是
测试意图：测试管理员删除一个不存在的帐号是否成功
测试步骤：1、删除一个不存在的帐号A，应该失败
'''
root_u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertFalse(root_u.delete("A"))
def Exception_test_level_3_1(self):
'''
是否实现：是
测试意图：修改一个不存在的用户
测试步骤：1、使用默认管理员admin修改一个不存在的租户帐号 ababbaba,应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertFalse(u.set_user_group("ababbaba", self.config_para.test_usergroup))
def auth_test_level_3_2(self):
'''
是否实现：是
测试意图：测试租户权限下，修改自己的电话，邮件，地址，描述信息
测试步骤：1、创建一个普通租户帐号A
2、登录A帐号，使用设置接口，修改自己的电话，邮件，地址，描述信息，应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
A_seesion = user.login(self.environment.server, "A", "test")
A_user = user.user(self.config_para.server_addr, A_seesion)
self.assertTrue(A_user.set_phone("A", "13770511182"))
self.assertTrue(A_user.set_email("A", "*****@*****.**"))
self.assertTrue(A_user.set_location("A", "zhong_xing_tong_xun"))
self.assertTrue(A_user.set_description("A", "test description"))
# 恢复环境.
self.assertTrue(u.delete("A"))
def auth_test_level_3_1(self):
'''
是否实现：是
测试意图：测试租户权限下，修改别人的信息
测试步骤：1、创建一个普通租户帐号A
2、再创建另一个普通租户帐号B
3、用A帐号登录，然后修改B帐号的描述信息，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
self.assertTrue(u.allocate("B", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
A_seesion = user.login(self.environment.server, "A", "test")
A_user = user.user(self.config_para.server_addr, A_seesion)
self.assertFalse(A_user.set_description("B", "test description"))
# 恢复环境
self.assertTrue(u.delete("A"))
self.assertTrue(u.delete("B"))
def auth_test_level_3_4(self):
'''
是否实现：否
测试意图：测试租户权限下，修改自己的群组信息(因为该用例有故障，用户可以设置自己的用户组)
测试步骤：1、创建一个普通租户帐号A
2、登录A帐号，使用设置接口，修改自己的群组信息，应该失败
'''
return
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
A_seesion = user.login(self.environment.server, "A", "test")
A_user = user.user(self.config_para.server_addr, A_seesion)
test_group = usergroup.usergroup(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(test_group.allocate("test_group", usergroup.GROUP_TYPE1))
self.assertFalse(A_user.set_user_group("A", "test_group"))
# 恢复环境
self.assertTrue(u.delete("A"))
self.assertTrue(test_group.delete("test_group"))
def auth_test_level_3_1(self):
'''
是否实现：是
测试意图：测试租户权限下，是否可以删除另一个租户的帐号
测试步骤：1、创建一个普通租户帐号A
2、再创建另一个普通租户帐号B
2、用A帐号登录，然后删除B帐号，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
self.assertTrue(u.allocate("B", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
A_session = user.login(self.environment.server, "A", "test")
A_user = user.user(self.config_para.server_addr, A_session)
self.assertFalse(A_user.delete("B"))
# 恢复环境
self.assertTrue(u.delete("A"))
self.assertTrue(u.delete("B"))
def normal_test_level_3_1(self):
'''
是否实现：是
测试意图：测试管理员是否能删除一个普通租户的帐号
测试步骤：1、使用管理员创建一个用户,然后删除该帐户，应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
# 恢复环境
self.assertTrue(u.delete("A"))
def normal_test_level_3_4(self):
'''
是否实现：是
测试意图：测试管理员帐号，创建另一个管理员帐号的流程
测试步骤：在用户组test_usergroup下面，增加一个管理员帐号，用户名为A，应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.CLOUDADMIN, self.config_para.test_usergroup))
#还原测试环境
self.assertTrue(u.delete("A"))
def normal_test_level_3_1(self):
'''
是否实现：是
测试意图：测试创建一个租户帐号流程
测试步骤：在用户组test_usergroup下面，增加一个普通租户帐号，用户名为A，应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
#还原测试环境
self.assertTrue(u.delete("A"))
def Exception_test_level_3_1(self):
'''
是否实现：是
测试意图：测试创建重名用户的流程
测试步骤：1、在用户组cigroup下面，增加一个普通租户帐号，用户名为A，应该成功
2、在用户组cigroup下面，增加一个普通租户帐号，用户名为A，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
self.assertFalse(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
#还原测试环境
self.assertTrue(u.delete("A"))
def normal_test_level_3_7(self):
'''
是否实现：是
测试意图：管理员禁用另一个管理员
测试步骤：1、管理员用户admin 创建一个管理员帐号admin_A
2、禁用帐号A,应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("admin_A", "test", "test", user.CLOUDADMIN, self.config_para.test_usergroup))
self.assertTrue(u.set_enable_disable("admin_A", user.USER_DISABLE))
# 恢复环境
self.assertTrue(u.delete("admin_A"))
def normal_test_level_3_4(self):
'''
是否实现：是
测试意图：管理员修改普通租户的角色为管理员
测试步骤：1、管理员用户admin 创建一个普通租户A
2、修改租户A的角色为管理员，应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
self.assertTrue(u.set_role("A", user.CLOUDADMIN))
# 恢复环境
self.assertTrue(u.delete("A"))
def normal_test_level_3_5(self):
'''
是否实现：是
测试意图：管理员禁用一个租户
测试步骤：1、管理员用户admin 创建一个租户A
2、禁用租户A,应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
self.assertTrue(u.set_enable_disable("A", user.USER_DISABLE))
# 恢复环境
self.assertTrue(u.delete("A"))
def normal_test_level_3_1(self):
'''
是否实现：是
测试意图：管理员修改另外一个管理的角色为普通租户
测试步骤：1、管理员用户admin 创建另一个管理员admin_A
2、然后管理员admin修改另一个管理员admin_A的权限为普通租户，应该成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("admin_A", "test", "test", user.CLOUDADMIN, self.config_para.test_usergroup))
self.assertTrue(u.set_role("admin_A", user.ACCOUNTUSER))
# 恢复环境
self.assertTrue(u.delete("admin_A"))
def Exception_test_level_3_2(self):
'''
是否实现：是
测试意图：修改用户的用户组到一个不存在的用户组情况
测试步骤：1、使用默认管理员admin创建一个租户帐号A，密码为test
2、修改租户A的用户组为“test_A”,应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
self.assertFalse(u.set_user_group("A", "test_A"))
# 恢复环境
self.assertTrue(u.delete("A"))
def limit_test_level_3_1(self):
'''
是否实现：是
测试意图：命名长度测试
测试步骤：1、创建用户名称长度等于65个字符的，普通租户帐号，应当失败
2、创建用户名称长度等于64个字符的，普通租户帐号，应当成功
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
name = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz012"
self.assertFalse(u.allocate(name, "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
name = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz01"
self.assertTrue(u.allocate(name, "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
#还原测试环境
self.assertTrue(u.delete(name))
def limit_test_level_3_2(self):
'''
是否实现：是
测试意图：命名格式测试
测试步骤：1、创建用户名为[email protected]，普通租户帐号，应当成功
2、创建用户名为[email protected]，普通租户帐号，应当失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
name = "[email protected]"
self.assertFalse(u.allocate(name, "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
name = "*****@*****.**"
self.assertTrue(u.allocate(name, "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
#还原测试环境
self.assertTrue(u.delete(name))
def limit_test_level_3_2(self):
'''
是否实现：是
测试意图：测试修改密码和确认密码在边界上，不一致情况
测试步骤：1、创建一个租户A
2、修改密码为 32个1，确认密码是33个1，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
pwd = "11111111111111111111111111111111"
cof_pwd = "111111111111111111111111111111111"
self.assertFalse(u.set_pwd("A", pwd, cof_pwd))
# 恢复环境
self.assertTrue(u.delete("A"))
def limit_test_level_3_1(self):
'''
是否实现：是
测试意图：测试密码长度边界
测试步骤：1、创建一个租户A
2、修改密码为 32个1，应该成功
3、修改密码为33个1，应该失败
'''
u = user.user(self.config_para.server_addr, self.environment.get_root_session())
self.assertTrue(u.allocate("A", "test", "test", user.ACCOUNTUSER, self.config_para.test_usergroup))
limit_ok_pwd = "11111111111111111111111111111111"
self.assertTrue(u.set_pwd("A", limit_ok_pwd, limit_ok_pwd))
limit_error_pwd = "111111111111111111111111111111111"
self.assertFalse(u.set_pwd("A", limit_error_pwd, limit_error_pwd))
# 恢复环境
self.assertTrue(u.delete("A"))
