def test_positive_last_login_for_new_user(self):
"""Create new user with admin role and check last login updated for that user
:id: 967282d3-92d0-42ce-9ef3-e542d2883408
:customerscenario: true
:expectedresults: last login should be updated for user after login using hammer
:BZ: 1763816
:CaseLevel: Integration
"""
login = gen_string('alpha')
password = gen_string('alpha')
org_name = gen_string('alpha')
make_user({'login': login, 'password': password})
User.add_role({'login': login, 'role': 'System admin'})
result_before_login = User.list({'search': f'login = {login}'})
# this is because satellite uses the UTC timezone
before_login_time = datetime.datetime.utcnow()
assert result_before_login[0]['login'] == login
assert result_before_login[0]['last-login'] == ""
Org.with_user(username=login,
password=password).create({'name': org_name})
result_after_login = User.list({'search': f'login = {login}'})
# checking user last login should not be empty
assert result_after_login[0]['last-login'] != ""
after_login_time = datetime.datetime.strptime(
result_after_login[0]['last-login'], "%Y/%m/%d %H:%M:%S")
assert after_login_time > before_login_time
def test_list_user_4(self):
"""@Test: List User for all variations of Email Address
@Feature: User - list
@Steps:
1. Create User for all Email Address variations in [1] using valid
valid Username, First Name, Surname, Language, authorized by
2. List User
@Assert: User is listed
"""
for mail in (gen_string("alpha") + "@somemail.com",
gen_string("alphanumeric", 10) + "@somemail.com",
gen_string("numeric") + "@somemail.com",
gen_string("alphanumeric", 50) + "@somem.com"):
with self.subTest(mail):
user = make_user({'mail': mail})
self.__assert_exists(user)
result = UserObj.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertIn({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result)
def test_bugzilla_1204667(self):
"""@Test: List User for utf-8,latin variations of Email Address
@Feature: User - list
@Steps:
1. Create User with above Email Address variations in [1] using valid
valid Username, First Name, Surname, Language, authorized by
2. List User
@Assert: User is listed
@BZ: 1204667
"""
for mail in (gen_string("latin1") + "@somemail.com",
gen_string("utf8") + "@somemail.com"):
with self.subTest(mail):
user = make_user({'mail': mail})
self.__assert_exists(user)
result = UserObj.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertIn({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result)
def test_list_user_3(self, test_data):
"""@Test: List User for all variations of Surname
@Feature: User - list
@Steps:
1. Create User for all Surname variations in [1] using valid
Username, First Name, Email Address, Language, authorized by
2. List User
@Assert: User is listed
"""
user = make_user(test_data)
self.__assert_exists(user)
result = UserObj.list({
u'search': u'lastname = {0}'.format(test_data['lastname']),
})
# make sure user is in list result
self.assertIn(
{
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
},
result,
)
def test_bugzilla_1204667(self, test_data):
"""@Test: List User for utf-8,latin variations of Email Address
@Feature: User - list
@Steps:
1. Create User with above Email Address variations in [1] using valid
valid Username, First Name, Surname, Language, authorized by
2. List User
@Assert: User is listed
@BZ: 1204667
"""
user = make_user(test_data)
self.__assert_exists(user)
result = UserObj.list({
u'search': u'mail = {0}'.format(test_data['mail']),
})
# make sure user is in list result
self.assertIn(
{
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
},
result,
)
def test_import_users_default(self, test_data):
"""@test: Import all 3 users from the default data set (predefined
source).
@feature: Import Users
@assert: 3 Users created
"""
tmp_dir = self.default_dataset[0]
files = dict(self.default_dataset[1])
pwdfile = os.path.join(tmp_dir, gen_string('alpha', 6))
files['users'] = update_csv_values(
files['users'],
u'organization_id',
test_data,
self.default_dataset[0]
)
Import.organization({'csv-file': files['users']})
ssh_import = Import.user({
'csv-file': files['users'],
'new-passwords': pwdfile
})
self.assertEqual(ssh_import.return_code, 0)
# list the users and check whether users from csv are in the listing
logins = set(user['login'] for user in User.list().stdout)
imp_users = set(
user['username']
for user in csv_to_dataset([files['users']])
)
self.assertTrue(imp_users.issubset(logins))
def test_positive_list_email(self):
"""List User for all variations of Email Address
:id: 252f5583-6c34-43ae-9966-636fa0a2bb10
:expectedresults: User is listed
:CaseImportance: Critical
"""
valid_emails = (
gen_string("alpha") + "@somemail.com",
gen_string("alphanumeric", 10) + "@somemail.com",
gen_string("numeric") + "@somemail.com",
gen_string("alphanumeric", 50) + "@somem.com"
)
for mail in valid_emails:
with self.subTest(mail):
user = make_user({'mail': mail})
result = User.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertEqual({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_positive_create_with_email_utf8_latin(self):
"""List User for utf-8,latin variations of Email Address
:id: 3d865df5-2e28-44fb-add8-c79a18db2f95
:expectedresults: User is listed
:BZ: 1204667
:CaseImportance: Critical
"""
valid_mails = (
gen_string("latin1") + "@somemail.com",
gen_string("utf8") + "@somemail.com"
)
for mail in valid_mails:
with self.subTest(mail):
user = make_user({'mail': mail})
result = User.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertIn({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result)
def test_positive_list_email(self):
"""List User for all variations of Email Address
:id: 252f5583-6c34-43ae-9966-636fa0a2bb10
:expectedresults: User is listed
:CaseImportance: Critical
"""
valid_emails = (gen_string("alpha") + "@somemail.com",
gen_string("alphanumeric", 10) + "@somemail.com",
gen_string("numeric") + "@somemail.com",
gen_string("alphanumeric", 50) + "@somem.com")
for mail in valid_emails:
with self.subTest(mail):
user = make_user({'mail': mail})
result = User.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertEqual(
{
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_positive_create_with_email_utf8_latin(self):
"""List User for utf-8,latin variations of Email Address
:id: 3d865df5-2e28-44fb-add8-c79a18db2f95
:expectedresults: User is listed
:BZ: 1204667
:CaseImportance: Critical
"""
valid_mails = (gen_string("latin1") + "@somemail.com",
gen_string("utf8") + "@somemail.com")
for mail in valid_mails:
with self.subTest(mail):
user = make_user({'mail': mail})
result = User.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertIn(
{
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result)
def test_list_user_3(self):
"""@Test: List User for all variations of Surname
@Feature: User - list
@Steps:
1. Create User for all Surname variations in [1] using valid
Username, First Name, Email Address, Language, authorized by
2. List User
@Assert: User is listed
"""
include_list = [gen_string("alphanumeric", 50)]
for lastname in valid_usernames_list() + include_list:
with self.subTest(lastname):
user = make_user({'lastname': lastname})
self.__assert_exists(user)
result = UserObj.list({
u'search': u'lastname = {0}'.format(lastname),
})
# make sure user is in list result
self.assertIn({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result)
def __assert_exists(self, user):
"""Checks if the object that passed as user parameter really exists
in `hammer user list --search user['login']` and has values of:
Login,Name,Email
"""
result = UserObj.list({
u'search': u'login="******"'.format(user['login']),
})
self.assertEqual(result[0]['name'], user['name'])
self.assertEqual(result[0]['email'], user['email'])
def test_reimport_users_default_negative(self, test_data):
"""@test: Try to Import all users from the
predefined source and try to import them again
@feature: Repetitive User Import
@assert: 2nd Import will result in No Action Taken
"""
tmp_dir = self.default_dataset[0]
files = dict(self.default_dataset[1])
pwdfile = os.path.join(tmp_dir, gen_string('alpha', 6))
files['users'] = update_csv_values(
files['users'],
u'organization_id',
test_data,
self.default_dataset[0]
)
# Import the organizations first
self.assertEqual(
Import.organization({
'csv-file': files['users'],
}).return_code, 0)
self.assertEqual(
Import.user({
'csv-file': files['users'],
'new-passwords': pwdfile,
}).return_code, 0)
ssh.command(u'rm -rf {}'.format(pwdfile))
users_before = set(user['login'] for user in User.list().stdout)
self.assertEqual(
Import.user({
'csv-file': files['users'],
'new-passwords': pwdfile,
}).return_code, 0)
users_after = set(user['login'] for user in User.list().stdout)
self.assertTrue(users_after.issubset(users_before))
def test_automation_bz_1110337(self):
"""@Test: Automation of BZ 1110337
@Feature: User - info, list BZ
@Assert: No undefined method exception
"""
users = [make_user() for _ in range(4)]
# non-existing user info
with self.assertRaises(CLIReturnCodeError) as exe:
UserObj.info({'id': 0})
self.assertNotRegexpMatches(exe.exception.stderr, 'undefined method')
# list users
result = UserObj.list()
for user in users:
self.assertNotEqual(str(result).find(user['login']), -1)
def test_positive_list_username(self):
"""List User for all variations of Username
:id: 3beef11a-c1d0-4b8f-a9f9-1eb557b36579
:expectedresults: User is listed
:CaseImportance: Critical
"""
for login in valid_usernames_list():
with self.subTest(login):
user = make_user({'login': login})
result = User.list({
u'search': u'login = {0}'.format(login),
})
self.assertEqual(len(result), 1)
# make sure user is in list result
self.assertEqual({user['id'], user['login']},
{result[0]['id'], result[0]['login']})
def test_positive_list_surname(self):
"""List User for all variations of Surname
:id: 1fcc6b76-28d8-4253-86b0-dae09703abe1
:expectedresults: User is listed
:CaseImportance: Critical
"""
for lastname in valid_usernames_list():
with self.subTest(lastname):
user = make_user({'lastname': lastname})
result = User.list({
u'search': u'lastname = {0}'.format(lastname),
})
# make sure user is in list result
self.assertEqual(
{user['id'], user['login'], user['name']},
{result[0]['id'], result[0]['login'], result[0]['name']}
)
def test_positive_list_surname(self):
"""List User for all variations of Surname
@id: 1fcc6b76-28d8-4253-86b0-dae09703abe1
@Assert: User is listed
"""
for lastname in valid_usernames_list():
with self.subTest(lastname):
user = make_user({'lastname': lastname})
result = User.list({
u'search': u'lastname = {0}'.format(lastname),
})
# make sure user is in list result
self.assertEqual({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_positive_list_surname(self):
"""List User for all variations of Surname
:id: 1fcc6b76-28d8-4253-86b0-dae09703abe1
:expectedresults: User is listed
:CaseImportance: Critical
"""
for lastname in valid_usernames_list():
with self.subTest(lastname):
user = make_user({'lastname': lastname})
result = User.list({
u'search':
u'lastname = {0}'.format(lastname),
})
# make sure user is in list result
self.assertEqual(
{user['id'], user['login'], user['name']},
{result[0]['id'], result[0]['login'], result[0]['name']})
def test_positive_list_firstname(self):
"""List User for all variations of First Name
:id: 7786d834-f899-4277-b7ed-5d66605fb746
:expectedresults: User is listed
:CaseImportance: Critical
"""
for firstname in valid_usernames_list():
with self.subTest(firstname):
user = make_user({'firstname': firstname})
result = User.list({
u'search': u'firstname = {0}'.format(firstname),
})
# make sure user is in list result
self.assertEqual(
{user['id'], user['login'], user['name']},
{result[0]['id'], result[0]['login'], result[0]['name']}
)
def test_positive_list_surname(self):
"""List User for all variations of Surname
@id: 1fcc6b76-28d8-4253-86b0-dae09703abe1
@Assert: User is listed
"""
for lastname in valid_usernames_list():
with self.subTest(lastname):
user = make_user({'lastname': lastname})
result = User.list({
u'search': u'lastname = {0}'.format(lastname),
})
# make sure user is in list result
self.assertEqual({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_list_user_4(self, test_data):
"""
@Test: List User for all variations of Email Address
@Feature: User - list
@Steps:
1. Create User for all Email Address variations in [1] using valid
valid Username, First Name, Surname, Language, authorized by
2. List User
@Assert: User is listed
"""
user = make_user(test_data)
self.__assert_exists(user)
result = UserObj.list({'search': 'mail = %s' % test_data['mail']})
self.assertEqual(len(result.stderr), 0)
# make sure user is in list result
self.assertTrue({
'name': user['name'],
'login': user['login'],
'id': user['id'],
'email': user['mail']} in result.stdout)
def test_positive_list_firstname(self):
"""List User for all variations of First Name
@id: 7786d834-f899-4277-b7ed-5d66605fb746
@Assert: User is listed
"""
for firstname in valid_usernames_list():
with self.subTest(firstname):
user = make_user({'firstname': firstname})
result = User.list({
u'search': u'firstname = {0}'.format(firstname),
})
# make sure user is in list result
self.assertEqual({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_positive_list_firstname(self):
"""List User for all variations of First Name
@id: 7786d834-f899-4277-b7ed-5d66605fb746
@Assert: User is listed
"""
for firstname in valid_usernames_list():
with self.subTest(firstname):
user = make_user({'firstname': firstname})
result = User.list({
u'search': u'firstname = {0}'.format(firstname),
})
# make sure user is in list result
self.assertEqual({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_positive_list_firstname(self):
"""List User for all variations of First Name
:id: 7786d834-f899-4277-b7ed-5d66605fb746
:expectedresults: User is listed
:CaseImportance: Critical
"""
for firstname in valid_usernames_list():
with self.subTest(firstname):
user = make_user({'firstname': firstname})
result = User.list({
u'search':
u'firstname = {0}'.format(firstname),
})
# make sure user is in list result
self.assertEqual(
{user['id'], user['login'], user['name']},
{result[0]['id'], result[0]['login'], result[0]['name']})
def test_positive_list_username(self):
"""List User for all variations of Username
:id: 3beef11a-c1d0-4b8f-a9f9-1eb557b36579
:expectedresults: User is listed
:CaseImportance: Critical
"""
for login in valid_usernames_list():
with self.subTest(login):
user = make_user({'login': login})
result = User.list({
u'search': u'login = {0}'.format(login),
})
self.assertEqual(len(result), 1)
# make sure user is in list result
self.assertEqual(
{user['id'], user['login']},
{result[0]['id'], result[0]['login']}
)
def test_positive_list_username(self):
"""List User for all variations of Username
@id: 3beef11a-c1d0-4b8f-a9f9-1eb557b36579
@Assert: User is listed
"""
for login in valid_usernames_list():
with self.subTest(login):
user = make_user({'login': login})
result = User.list({
u'search': u'login = {0}'.format(login),
})
self.assertEqual(len(result), 1)
# make sure user is in list result
self.assertEqual({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_positive_list_username(self):
"""List User for all variations of Username
@id: 3beef11a-c1d0-4b8f-a9f9-1eb557b36579
@Assert: User is listed
"""
for login in valid_usernames_list():
with self.subTest(login):
user = make_user({'login': login})
result = User.list({
u'search': u'login = {0}'.format(login),
})
self.assertEqual(len(result), 1)
# make sure user is in list result
self.assertEqual({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_merge_orgs(self, test_data):
"""@test: Try to Import all organizations and their users from CSV
to a mapped organizaition.
@feature: Import User Mapped Org
@assert: 3 Organizations Mapped and their Users created
in a single Organization
"""
# create a new Organization and prepare CSV files
new_org = make_org()
tmp_dir = self.default_dataset[0]
files = dict(self.default_dataset[1])
pwdfile = os.path.join(tmp_dir, gen_string('alpha', 6))
files['users'] = update_csv_values(
files['users'],
u'organization_id',
test_data,
self.default_dataset[0]
)
self.assertEqual(
Import.organization({
'csv-file': files['users'],
'into-org-id': new_org['id'],
'verbose': True,
}).return_code,
0
)
Import.user({'csv-file': files['users'], 'new-passwords': pwdfile})
# list users by org-id and check whether users from csv are in listing
users = User.list({u'organization-id': new_org['id']})
logins = set(user['login'] for user in users.stdout)
imp_users = set(
user['username']
for user in csv_to_dataset([files['users']])
)
self.assertTrue(all((user in logins for user in imp_users)))
def test_positive_list_email(self):
"""List User for all variations of Email Address
@Feature: User - list
@Assert: User is listed
"""
for mail in (gen_string("alpha") + "@somemail.com",
gen_string("alphanumeric", 10) + "@somemail.com",
gen_string("numeric") + "@somemail.com",
gen_string("alphanumeric", 50) + "@somem.com"):
with self.subTest(mail):
user = make_user({'mail': mail})
result = User.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertEqual({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_positive_create_with_email_utf8_latin(self):
"""List User for utf-8,latin variations of Email Address
@Feature: User - list
@Assert: User is listed
@BZ: 1204667
"""
for mail in (gen_string("latin1") + "@somemail.com",
gen_string("utf8") + "@somemail.com"):
with self.subTest(mail):
user = make_user({'mail': mail})
result = User.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertIn({
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result)
def test_positive_list_email(self):
"""List User for all variations of Email Address
@Feature: User - list
@Assert: User is listed
"""
for mail in (gen_string("alpha") + "@somemail.com",
gen_string("alphanumeric", 10) + "@somemail.com",
gen_string("numeric") + "@somemail.com",
gen_string("alphanumeric", 50) + "@somem.com"):
with self.subTest(mail):
user = make_user({'mail': mail})
result = User.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertEqual(
{
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result[0])
def test_positive_create_with_email_utf8_latin(self):
"""List User for utf-8,latin variations of Email Address
@Feature: User - list
@Assert: User is listed
@BZ: 1204667
"""
for mail in (gen_string("latin1") + "@somemail.com",
gen_string("utf8") + "@somemail.com"):
with self.subTest(mail):
user = make_user({'mail': mail})
result = User.list({
u'search': u'mail = {0}'.format(mail),
})
# make sure user is in list result
self.assertIn(
{
'email': user['email'],
'id': user['id'],
'login': user['login'],
'name': user['name'],
}, result)
def test_positive_CRUD(self):
"""Create User with various parameters, updating and deleting
:id: 2d430243-8512-46ee-8d21-7ccf0c7af807
:expectedresults: User is created with parameters, parameters
are updated, user is deleted
:CaseImportance: Critical
"""
# create with params
mail = random.choice(valid_emails_list())
user_params = {
'login': random.choice(valid_usernames_list()),
'firstname': random.choice(valid_usernames_list()),
'lastname': random.choice(valid_usernames_list()),
'mail': mail.replace('"', r'\"').replace('`', r'\`'),
'description': random.choice(list(valid_data_list().values())),
}
user = make_user(user_params)
user['firstname'], user['lastname'] = user['name'].split()
user_params.pop('mail')
user_params['email'] = mail
for key in user_params:
assert user_params[key] == user[
key], f'values for key "{key}" do not match'
# list by firstname and lastname
result = User.list(
{'search': 'firstname = {}'.format(user_params['firstname'])})
# make sure user is in list result
assert {user['id'], user['login'], user['name']} == {
result[0]['id'],
result[0]['login'],
result[0]['name'],
}
result = User.list(
{'search': 'lastname = {}'.format(user_params['lastname'])})
# make sure user is in list result
assert {user['id'], user['login'], user['name']} == {
result[0]['id'],
result[0]['login'],
result[0]['name'],
}
# update params
new_mail = random.choice(valid_emails_list())
user_params = {
'firstname': random.choice(valid_usernames_list()),
'lastname': random.choice(valid_usernames_list()),
'mail': new_mail.replace('"', r'\"').replace('`', r'\`'),
'description': random.choice(list(valid_data_list().values())),
}
user_params.update({'id': user['id']})
User.update(user_params)
user = User.info({'login': user['login']})
user['firstname'], user['lastname'] = user['name'].split()
user_params.pop('mail')
user_params['email'] = new_mail
for key in user_params:
assert user_params[key] == user[
key], f'values for key "{key}" do not match'
# delete
User.delete({'login': user['login']})
with pytest.raises(CLIReturnCodeError):
User.info({'login': user['login']})
def test_import_users_recovery(self, test_data):
"""@test: Try to Import users with the same name to invoke
usage of a recovery strategy (rename, map, none)
@feature: Import Users Recover
@assert: 2nd Import will rename new users, 3rd one will result
in No Action Taken and 4th import will map them
"""
# prepare the data
tmp_dir = self.default_dataset[0]
files = dict(self.default_dataset[1])
pwdfiles = [
os.path.join(tmp_dir, gen_string('alpha', 6)) for _ in range(4)
]
files['users'] = update_csv_values(
files['users'],
u'organization_id',
test_data,
self.default_dataset[0]
)
# initial import
for result in (
Import.organization({'csv-file': files['users']}),
Import.user({
'csv-file': files['users'],
'new-passwords': pwdfiles[0],
}),
):
self.assertEqual(result.return_code, 0)
# clear the .transition_data to clear the transition mapping
ssh.command('rm -rf "${HOME}"/.transition_data/users*')
# use the default (rename) strategy
import_rename = Import.user_with_tr_data({
'csv-file': files['users'],
'new-passwords': pwdfiles[1],
})
for record in import_rename[1]:
self.assertEqual(User.info({'id': record['sat6']}).return_code, 0)
Import.user({'csv-file': files['users'], 'delete': True})
# use the 'none' strategy
users_before = set(user['login'] for user in User.list().stdout)
Import.user({
'csv-file': files['users'],
'new-passwords': pwdfiles[2],
'recover': 'none',
})
users_after = set(user['login'] for user in User.list().stdout)
self.assertEqual(users_before, users_after)
# use the 'map' strategy
import_map = Import.user_with_tr_data({
'csv-file': files['users'],
'recover': 'map',
'new-passwords': pwdfiles[3],
})
for record in import_map[1]:
self.assertEqual(
User.info({'id': record['sat6']}).return_code, 0
)
# do the cleanup
ssh.command(u'rm -rf {}'.format(' '.join(pwdfiles)))
