def test_return_type(self):
"""This test validates return types for functions:
1. :meth:`robottelo.datafactory.generate_strings_list`
2. :meth:`robottelo.datafactory.invalid_emails_list`
3. :meth:`robottelo.datafactory.invalid_names_list`
4. :meth:`robottelo.datafactory.valid_data_list`
5. :meth:`robottelo.datafactory.valid_emails_list`
6. :meth:`robottelo.datafactory.valid_environments_list`
7. :meth:`robottelo.datafactory.valid_labels_list`
8. :meth:`robottelo.datafactory.valid_names_list`
9. :meth:`robottelo.datafactory.valid_usernames_list`
10. :meth:`robottelo.datafactory.invalid_id_list`
"""
for item in itertools.chain(
generate_strings_list(),
invalid_emails_list(),
invalid_names_list(),
valid_data_list(),
valid_emails_list(),
valid_environments_list(),
valid_labels_list(),
valid_names_list(),
valid_usernames_list(),):
self.assertIsInstance(item, six.text_type)
for item in invalid_id_list():
if not (isinstance(item, (six.text_type, int)) or item is None):
self.fail('Unexpected data type')
def test_positive_virtwho_manager_role(self, session, test_name,
form_data):
"""Verify the virt-who manager role can TRULY work.
:id: a72023fb-7b23-4582-9adc-c5227dc7859c
:expectedresults:
Virt-who Manager Role granting all permissions to manage virt-who configurations,
user needs this role to create, delete or update configurations.
"""
username = gen_string('alpha')
password = gen_string('alpha')
config_name = gen_string('alpha')
with session:
# Create an user
session.user.create({
'user.login': username,
'user.mail': valid_emails_list()[0],
'user.auth': 'INTERNAL',
'user.password': password,
'user.confirm': password,
})
# Create a virt-who config plugin
form_data['name'] = config_name
session.virtwho_configure.create(form_data)
values = session.virtwho_configure.read(config_name)
command = values['deploy']['command']
deploy_configure_by_command(command, form_data['hypervisor_type'])
assert session.virtwho_configure.search(
config_name)[0]['Status'] == 'ok'
# Check the permissioin of Virt-who Manager
session.user.update(
username, {'roles.resources.assigned': ['Virt-who Manager']})
user = session.user.read(username)
assert user['roles']['resources']['assigned'] == [
'Virt-who Manager'
]
with Session(test_name, username, password) as newsession:
# create_virt_who_config
new_virt_who_name = gen_string('alpha')
form_data['name'] = new_virt_who_name
newsession.virtwho_configure.create(form_data)
# view_virt_who_config
values = newsession.virtwho_configure.read(new_virt_who_name)
command = values['deploy']['command']
deploy_configure_by_command(command,
form_data['hypervisor_type'])
assert newsession.virtwho_configure.search(
new_virt_who_name)[0]['Status'] == 'ok'
# edit_virt_who_config
modify_name = gen_string('alpha')
newsession.virtwho_configure.edit(new_virt_who_name,
{'name': modify_name})
newsession.virtwho_configure.search(modify_name)
# destroy_virt_who_config
newsession.virtwho_configure.delete(modify_name)
assert not newsession.virtwho_configure.search(modify_name)
# Delete the created user
session.user.delete(username)
assert not session.user.search(username)
def test_filtered_datapoint_True(self):
"""Tests if run_one_datapoint=false returns all data points"""
settings.run_one_datapoint = False
self.assertEqual(len(generate_strings_list()), 7)
self.assertEqual(len(invalid_emails_list()), 8)
self.assertEqual(len(invalid_id_list()), 4)
self.assertEqual(len(invalid_interfaces_list()), 8)
self.assertEqual(len(invalid_names_list()), 7)
self.assertEqual(len(invalid_values_list()), 10)
self.assertEqual(len(invalid_usernames_list()), 4)
self.assertEqual(len(valid_labels_list()), 2)
self.assertEqual(len(valid_data_list()), 7)
self.assertEqual(len(valid_emails_list()), 8)
self.assertEqual(len(valid_environments_list()), 4)
self.assertEqual(len(valid_hosts_list()), 3)
self.assertEqual(len(valid_hostgroups_list()), 7)
self.assertEqual(len(valid_interfaces_list()), 3)
self.assertEqual(len(valid_names_list()), 15)
self.assertEqual(len(valid_org_names_list()), 7)
self.assertEqual(len(valid_usernames_list()), 6)
self.assertEqual(len((valid_cron_expressions())), 4)
with mock.patch('robottelo.datafactory.bz_bug_is_open',
return_value=True):
self.assertEqual(len(valid_docker_repository_names()), 6)
with mock.patch('robottelo.datafactory.bz_bug_is_open',
return_value=False):
self.assertEqual(len(valid_docker_repository_names()), 7)
def test_filtered_datapoint_True(self):
"""Tests if run_one_datapoint=false returns all data points"""
settings.run_one_datapoint = False
self.assertEqual(len(generate_strings_list()), 7)
self.assertEqual(len(invalid_emails_list()), 8)
self.assertEqual(len(invalid_id_list()), 4)
self.assertEqual(len(invalid_interfaces_list()), 8)
self.assertEqual(len(invalid_names_list()), 7)
self.assertEqual(len(invalid_values_list()), 10)
self.assertEqual(len(invalid_usernames_list()), 4)
self.assertEqual(len(valid_labels_list()), 2)
self.assertEqual(len(valid_data_list()), 7)
self.assertEqual(len(valid_emails_list()), 8)
self.assertEqual(len(valid_environments_list()), 4)
self.assertEqual(len(valid_hosts_list()), 3)
self.assertEqual(len(valid_hostgroups_list()), 7)
self.assertEqual(len(valid_interfaces_list()), 3)
self.assertEqual(len(valid_names_list()), 15)
self.assertEqual(len(valid_org_names_list()), 7)
self.assertEqual(len(valid_usernames_list()), 6)
with mock.patch('robottelo.datafactory.bz_bug_is_open',
return_value=True):
self.assertEqual(len(valid_docker_repository_names()), 6)
with mock.patch('robottelo.datafactory.bz_bug_is_open',
return_value=False):
self.assertEqual(len(valid_docker_repository_names()), 7)
def test_positive_virtwho_viewer_role(self, session, test_name, form_data):
"""Verify the virt-who viewer role can TRULY work.
:id: bf3be2e4-3853-41cc-9b3e-c8677f0b8c5f
:expectedresults:
Virt-who Viewer Role granting permissions to see all configurations
including their configuration scripts, which means viewers could still
deploy the virt-who instances for existing virt-who configurations.
"""
username = gen_string('alpha')
password = gen_string('alpha')
config_name = gen_string('alpha')
with session:
# Create an user
session.user.create({
'user.login': username,
'user.mail': valid_emails_list()[0],
'user.auth': 'INTERNAL',
'user.password': password,
'user.confirm': password,
})
# Create a virt-who config plugin
form_data['name'] = config_name
session.virtwho_configure.create(form_data)
values = session.virtwho_configure.read(config_name)
command = values['deploy']['command']
deploy_configure_by_command(command, form_data['hypervisor_type'])
assert session.virtwho_configure.search(
config_name)[0]['Status'] == 'ok'
# Check the permissioin of Virt-who Viewer
session.user.update(
username, {'roles.resources.assigned': ['Virt-who Viewer']})
user = session.user.read(username)
assert user['roles']['resources']['assigned'] == [
'Virt-who Viewer'
]
# Update the virt-who config file
config_id = get_configure_id(config_name)
config_file = get_configure_file(config_id)
update_configure_option('rhsm_username', username, config_file)
delete_configure_option('rhsm_encrypted_password', config_file)
add_configure_option('rhsm_password', password, config_file)
restart_virtwho_service()
assert get_virtwho_status() == 'logerror'
with Session(test_name, username, password) as newsession:
create_permission = newsession.virtwho_configure.check_create_permission(
)
update_permission = newsession.virtwho_configure.check_update_permission(
config_name)
assert create_permission['can_view']
assert not create_permission['can_create']
assert not update_permission['can_delete']
assert not update_permission['can_edit']
newsession.virtwho_configure.read(config_name)
# Delete the created user
session.user.delete(username)
assert not session.user.search(username)
def test_positive_virtwho_reporter_role(self, default_org, session,
test_name, form_data):
"""Verify the virt-who reporter role can TRULY work.
:id: cd235ab0-d89c-464b-98d6-9d090ac40d8f
:expectedresults:
Virt-who Reporter Role granting minimal set of permissions for virt-who
to upload the report, it can be used if you configure virt-who manually
and want to use user that has locked down account.
"""
username = gen_string('alpha')
password = gen_string('alpha')
config_name = gen_string('alpha')
with session:
# Create an user
session.user.create({
'user.login': username,
'user.mail': valid_emails_list()[0],
'user.auth': 'INTERNAL',
'user.password': password,
'user.confirm': password,
})
# Create a virt-who config plugin
form_data['name'] = config_name
session.virtwho_configure.create(form_data)
values = session.virtwho_configure.read(config_name)
command = values['deploy']['command']
deploy_configure_by_command(command,
form_data['hypervisor_type'],
org=default_org.label)
assert session.virtwho_configure.search(
config_name)[0]['Status'] == 'ok'
# Update the virt-who config file
config_id = get_configure_id(config_name)
config_file = get_configure_file(config_id)
update_configure_option('rhsm_username', username, config_file)
delete_configure_option('rhsm_encrypted_password', config_file)
add_configure_option('rhsm_password', password, config_file)
restart_virtwho_service()
assert get_virtwho_status() == 'logerror'
# Check the permissioin of Virt-who Reporter
session.user.update(
username, {'roles.resources.assigned': ['Virt-who Reporter']})
assert session.user.search(username)[0]['Username'] == username
user = session.user.read(username)
assert user['roles']['resources']['assigned'] == [
'Virt-who Reporter'
]
restart_virtwho_service()
assert get_virtwho_status() == 'running'
with Session(test_name, username, password) as newsession:
assert not newsession.virtwho_configure.check_create_permission(
)['can_view']
session.user.delete(username)
assert not session.user.search(username)
def test_filtered_datapoint(self, run_one_datapoint):
"""Tests if run_one_datapoint=false returns all data points"""
if run_one_datapoint:
assert len(datafactory.generate_strings_list()) == 1
assert len(datafactory.invalid_emails_list()) == 1
assert len(datafactory.invalid_environments_list()) == 1
assert len(datafactory.invalid_id_list()) == 1
assert len(datafactory.invalid_interfaces_list()) == 1
assert len(datafactory.invalid_names_list()) == 1
assert len(datafactory.invalid_values_list()) == 1
assert len(datafactory.valid_data_list()) == 1
assert len(datafactory.valid_docker_repository_names()) == 1
assert len(datafactory.valid_emails_list()) == 1
assert len(datafactory.valid_environments_list()) == 1
assert len(datafactory.valid_hosts_list()) == 1
assert len(datafactory.valid_hostgroups_list()) == 1
assert len(datafactory.valid_interfaces_list()) == 1
assert len(datafactory.valid_labels_list()) == 1
assert len(datafactory.valid_names_list()) == 1
assert len(datafactory.valid_org_names_list()) == 1
assert len(datafactory.valid_usernames_list()) == 1
assert len(datafactory.valid_cron_expressions()) == 1
else:
assert len(datafactory.generate_strings_list()) == 7
assert len(datafactory.invalid_emails_list()) == 8
assert len(datafactory.invalid_environments_list()) == 4
assert len(datafactory.invalid_id_list()) == 4
assert len(datafactory.invalid_interfaces_list()) == 8
assert len(datafactory.invalid_names_list()) == 7
assert len(datafactory.invalid_values_list()) == 10
assert len(datafactory.invalid_usernames_list()) == 4
assert len(datafactory.valid_labels_list()) == 2
assert len(datafactory.valid_data_list()) == 7
assert len(datafactory.valid_emails_list()) == 8
assert len(datafactory.valid_environments_list()) == 4
assert len(datafactory.valid_hosts_list()) == 3
assert len(datafactory.valid_hostgroups_list()) == 7
assert len(datafactory.valid_interfaces_list()) == 3
assert len(datafactory.valid_names_list()) == 15
assert len(datafactory.valid_org_names_list()) == 7
assert len(datafactory.valid_usernames_list()) == 6
assert len(datafactory.valid_cron_expressions()) == 4
assert len(datafactory.valid_docker_repository_names()) == 7
def test_positive_create_with_email(self):
"""Create User for all variations of Email
@id: e68caf51-44ba-4d32-b79b-9ab9b67b9590
@Assert: User is created
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
self.assertEqual(user.mail, mail)
def test_positive_create_with_email(self):
"""Create User for all variations of Email
@Feature: User - Positive Create
@Assert: User is created
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
self.assertEqual(user.mail, mail)
def test_positive_create_with_email(self):
"""Create User for all variations of Email
@id: e68caf51-44ba-4d32-b79b-9ab9b67b9590
@Assert: User is created
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
self.assertEqual(user.mail, mail)
def test_positive_create_with_email(self):
"""Create User for all variations of Email
@Feature: User - Positive Create
@Assert: User is created
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
self.assertEqual(user.mail, mail)
def test_positive_delete(self):
"""Create random users and then delete it.
@id: df6059e7-85c5-42fa-99b5-b7f1ef809f52
@Assert: The user cannot be fetched after deletion.
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
user.delete()
with self.assertRaises(HTTPError):
user.read()
def test_positive_delete(self):
"""Create random users and then delete it.
@Assert: The user cannot be fetched after deletion.
@Feature: User
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
user.delete()
with self.assertRaises(HTTPError):
user.read()
def test_positive_create_with_email(self):
"""Create User for all variations of Email
:id: e68caf51-44ba-4d32-b79b-9ab9b67b9590
:expectedresults: User is created
:CaseImportance: Critical
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
self.assertEqual(user.mail, mail)
def test_positive_create_with_email(self):
"""Create User for all variations of Email Address
@id: 1c6c0f50-401c-4b7d-9795-97a1be3806f8
@Assert: User is created successfully
"""
with Session(self.browser) as session:
for email in valid_emails_list():
with self.subTest(email):
name = gen_string('alpha')
make_user(session, username=name, email=email)
self.user.validate_user(name, 'email', email)
def test_positive_delete(self):
"""Create random users and then delete it.
@Assert: The user cannot be fetched after deletion.
@Feature: User
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
user.delete()
with self.assertRaises(HTTPError):
user.read()
def test_positive_delete(self):
"""Create random users and then delete it.
@id: df6059e7-85c5-42fa-99b5-b7f1ef809f52
@Assert: The user cannot be fetched after deletion.
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
user.delete()
with self.assertRaises(HTTPError):
user.read()
def test_positive_create_with_email(self):
"""Create User for all variations of Email
:id: e68caf51-44ba-4d32-b79b-9ab9b67b9590
:expectedresults: User is created
:CaseImportance: Critical
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
self.assertEqual(user.mail, mail)
def test_positive_create_with_email(self):
"""Create User for all variations of Email Address
@Feature: User - Positive Create
@Assert: User is created successfully
"""
with Session(self.browser) as session:
for email in valid_emails_list():
with self.subTest(email):
name = gen_string('alpha')
make_user(session, username=name, email=email)
self.user.validate_user(name, 'email', email)
def test_positive_create_with_email(self):
"""Create User for all variations of Email Address
@id: 2c3ba244-3bd7-4455-8289-03dc7a28a4a6
@Assert: User is created
"""
for email in valid_emails_list():
with self.subTest(email):
# The email must be escaped because some characters to not fail
# the parsing of the generated shell command
escaped_email = email.replace('"', r'\"').replace('`', r'\`')
user = make_user({'mail': escaped_email})
self.assertEqual(user['email'], email)
def test_positive_create_with_email(self):
"""Create User for all variations of Email Address
@id: 2c3ba244-3bd7-4455-8289-03dc7a28a4a6
@Assert: User is created
"""
for email in valid_emails_list():
with self.subTest(email):
# The email must be escaped because some characters to not fail
# the parsing of the generated shell command
escaped_email = email.replace('"', r'\"').replace('`', r'\`')
user = make_user({'mail': escaped_email})
self.assertEqual(user['email'], email)
def test_datacheck_True(self):
"""Tests if run_one_datapoint=false returns all data points"""
settings.run_one_datapoint = False
self.assertEqual(len(generate_strings_list()), 7)
self.assertEqual(len(invalid_id_list()), 4)
self.assertEqual(len(invalid_emails_list()), 10)
self.assertEqual(len(invalid_names_list()), 7)
self.assertEqual(len(invalid_values_list()), 10)
self.assertEqual(len(valid_labels_list()), 2)
self.assertEqual(len(valid_data_list()), 7)
self.assertEqual(len(valid_emails_list()), 8)
self.assertEqual(len(valid_environments_list()), 3)
self.assertEqual(len(valid_names_list()), 15)
self.assertEqual(len(valid_usernames_list()), 4)
def test_datacheck_False(self):
"""Tests if run_one_datapoint=True returns one data point"""
settings.run_one_datapoint = True
self.assertEqual(len(generate_strings_list()), 1)
self.assertEqual(len(invalid_emails_list()), 1)
self.assertEqual(len(invalid_id_list()), 1)
self.assertEqual(len(invalid_names_list()), 1)
self.assertEqual(len(invalid_values_list()), 1)
self.assertEqual(len(valid_data_list()), 1)
self.assertEqual(len(valid_emails_list()), 1)
self.assertEqual(len(valid_environments_list()), 1)
self.assertEqual(len(valid_labels_list()), 1)
self.assertEqual(len(valid_names_list()), 1)
self.assertEqual(len(valid_usernames_list()), 1)
def test_positive_delete(self):
"""Create random users and then delete it.
:id: df6059e7-85c5-42fa-99b5-b7f1ef809f52
:expectedresults: The user cannot be fetched after deletion.
:CaseImportance: Critical
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
user.delete()
with self.assertRaises(HTTPError):
user.read()
def test_positive_create_with_email(self):
"""Create User for all variations of Email Address
:id: 1c6c0f50-401c-4b7d-9795-97a1be3806f8
:expectedresults: User is created successfully
:CaseImportance: Critical
"""
with Session(self.browser) as session:
for email in valid_emails_list():
with self.subTest(email):
name = gen_string('alpha')
make_user(session, username=name, email=email)
self.user.validate_user(name, 'email', email)
def test_positive_update_email(self):
"""Update a user and provide new email.
:id: 9eefcba6-66a3-41bf-87ba-3e032aee1db2
:expectedresults: The user's ``email`` attribute is updated.
:CaseImportance: Critical
"""
user = entities.User().create()
for mail in valid_emails_list():
with self.subTest(mail):
user.mail = mail
user = user.update(['mail'])
self.assertEqual(user.mail, mail)
def test_positive_update_email(self):
"""Update a user and provide new email.
:id: 3ae70631-7cee-4a4a-9c2f-b428273f1311
:expectedresults: The user's ``mail`` attribute is updated.
:CaseImportance: Critical
"""
user = entities.User().create()
for mail in valid_emails_list():
with self.subTest(mail):
user.mail = mail
user = user.update(['mail'])
self.assertEqual(user.mail, mail)
def test_positive_update_email(self):
"""Update a user and provide new email.
:id: 9eefcba6-66a3-41bf-87ba-3e032aee1db2
:expectedresults: The user's ``email`` attribute is updated.
:CaseImportance: Critical
"""
user = entities.User().create()
for mail in valid_emails_list():
with self.subTest(mail):
user.mail = mail
user = user.update(['mail'])
self.assertEqual(user.mail, mail)
def test_positive_delete(self):
"""Create random users and then delete it.
:id: df6059e7-85c5-42fa-99b5-b7f1ef809f52
:expectedresults: The user cannot be fetched after deletion.
:CaseImportance: Critical
"""
for mail in valid_emails_list():
with self.subTest(mail):
user = entities.User(mail=mail).create()
user.delete()
with self.assertRaises(HTTPError):
user.read()
def test_return_type(self):
"""This test validates return types for functions:
1. :meth:`robottelo.datafactory.generate_strings_list`
2. :meth:`robottelo.datafactory.invalid_emails_list`
3. :meth:`robottelo.datafactory.invalid_names_list`
4. :meth:`robottelo.datafactory.valid_data_list`
5. :meth:`robottelo.datafactory.valid_docker_repository_names`
6. :meth:`robottelo.datafactory.valid_emails_list`
7. :meth:`robottelo.datafactory.valid_environments_list`
8. :meth:`robottelo.datafactory.valid_hosts_list`
9. :meth:`robottelo.datafactory.valid_hostgroups_list`
10. :meth:`robottelo.datafactory.valid_labels_list`
11. :meth:`robottelo.datafactory.valid_names_list`
12. :meth:`robottelo.datafactory.valid_org_names_list`
13. :meth:`robottelo.datafactory.valid_usernames_list`
14. :meth:`robottelo.datafactory.invalid_id_list`
15. :meth:`robottelo.datafactory.invalid_interfaces_list`
16. :meth:`robottelo.datafactory.valid_interfaces_list`
17. :meth:`robottelo.datafactory.valid_cron_expressions`
"""
with mock.patch('robottelo.datafactory.bz_bug_is_open',
return_value=False):
for item in itertools.chain(
generate_strings_list(),
invalid_emails_list(),
invalid_interfaces_list(),
invalid_names_list(),
valid_data_list(),
valid_docker_repository_names(),
valid_emails_list(),
valid_environments_list(),
valid_hosts_list(),
valid_hostgroups_list(),
valid_interfaces_list(),
valid_labels_list(),
valid_names_list(),
valid_org_names_list(),
valid_cron_expressions(),
valid_usernames_list()):
self.assertIsInstance(item, six.text_type)
for item in invalid_id_list():
if not (
isinstance(item, (six.text_type, int)) or item is None
):
self.fail('Unexpected data type')
def test_filtered_datapoint_False(self):
"""Tests if run_one_datapoint=True returns one data point"""
settings.run_one_datapoint = True
self.assertEqual(len(generate_strings_list()), 1)
self.assertEqual(len(invalid_emails_list()), 1)
self.assertEqual(len(invalid_id_list()), 1)
self.assertEqual(len(invalid_names_list()), 1)
self.assertEqual(len(invalid_values_list()), 1)
self.assertEqual(len(valid_data_list()), 1)
self.assertEqual(len(valid_emails_list()), 1)
self.assertEqual(len(valid_environments_list()), 1)
self.assertEqual(len(valid_hosts_list()), 1)
self.assertEqual(len(valid_hostgroups_list()), 1)
self.assertEqual(len(valid_labels_list()), 1)
self.assertEqual(len(valid_names_list()), 1)
self.assertEqual(len(valid_org_names_list()), 1)
self.assertEqual(len(valid_usernames_list()), 1)
def test_return_type(self):
"""This test validates return types for functions:
1. :meth:`robottelo.datafactory.generate_strings_list`
2. :meth:`robottelo.datafactory.invalid_emails_list`
3. :meth:`robottelo.datafactory.invalid_environments_list`
4. :meth:`robottelo.datafactory.invalid_names_list`
5. :meth:`robottelo.datafactory.valid_data_list`
6. :meth:`robottelo.datafactory.valid_docker_repository_names`
7. :meth:`robottelo.datafactory.valid_emails_list`
8. :meth:`robottelo.datafactory.valid_environments_list`
9. :meth:`robottelo.datafactory.valid_hosts_list`
10. :meth:`robottelo.datafactory.valid_hostgroups_list`
11. :meth:`robottelo.datafactory.valid_labels_list`
12. :meth:`robottelo.datafactory.valid_names_list`
13. :meth:`robottelo.datafactory.valid_org_names_list`
14. :meth:`robottelo.datafactory.valid_usernames_list`
15. :meth:`robottelo.datafactory.invalid_id_list`
16. :meth:`robottelo.datafactory.invalid_interfaces_list`
17. :meth:`robottelo.datafactory.valid_interfaces_list`
18. :meth:`robottelo.datafactory.valid_cron_expressions`
"""
for item in itertools.chain(
datafactory.generate_strings_list(),
datafactory.invalid_emails_list(),
datafactory.invalid_environments_list(),
datafactory.invalid_interfaces_list(),
datafactory.invalid_names_list(),
datafactory.valid_data_list(),
datafactory.valid_docker_repository_names(),
datafactory.valid_emails_list(),
datafactory.valid_environments_list(),
datafactory.valid_hosts_list(),
datafactory.valid_hostgroups_list(),
datafactory.valid_interfaces_list(),
datafactory.valid_labels_list(),
datafactory.valid_names_list(),
datafactory.valid_org_names_list(),
datafactory.valid_cron_expressions(),
datafactory.valid_usernames_list(),
):
assert isinstance(item, str)
for item in datafactory.invalid_id_list():
if not (isinstance(item, (str, int)) or item is None):
pytest.fail('Unexpected data type')
def test_positive_update_email(self):
"""Update Email Address value for existing User
@id: 75067bf3-e43e-4c6a-b3fd-63e564eda7db
@Assert: User is updated
"""
user = self.user
for email in valid_emails_list():
with self.subTest(email):
User.update({
'id': user['id'],
# escape to avoid bash syntax error
'mail': email.replace('"', r'\"').replace('`', r'\`'),
})
result = User.info({'id': user['id']})
self.assertEqual(result['email'], email)
def test_positive_update_email(self):
"""Update Email Address value for existing User
@id: 75067bf3-e43e-4c6a-b3fd-63e564eda7db
@Assert: User is updated
"""
user = make_user()
for email in valid_emails_list():
with self.subTest(email):
User.update({
'id': user['id'],
# escape to avoid bash syntax error
'mail': email.replace('"', r'\"').replace('`', r'\`'),
})
result = User.info({'id': user['id']})
self.assertEqual(result['email'], email)
def test_filtered_datapoint_True(self):
"""Tests if run_one_datapoint=false returns all data points"""
settings.run_one_datapoint = False
self.assertEqual(len(generate_strings_list()), 7)
self.assertEqual(len(invalid_id_list()), 4)
self.assertEqual(len(invalid_emails_list()), 10)
self.assertEqual(len(invalid_names_list()), 7)
self.assertEqual(len(invalid_values_list()), 10)
self.assertEqual(len(invalid_usernames_list()), 4)
self.assertEqual(len(valid_labels_list()), 2)
self.assertEqual(len(valid_data_list()), 7)
self.assertEqual(len(valid_emails_list()), 8)
self.assertEqual(len(valid_environments_list()), 3)
self.assertEqual(len(valid_hosts_list()), 3)
self.assertEqual(len(valid_hostgroups_list()), 7)
self.assertEqual(len(valid_names_list()), 15)
self.assertEqual(len(valid_org_names_list()), 7)
self.assertEqual(len(valid_usernames_list()), 6)
def test_positive_create_user_4(self):
"""@Test: Create User for all variations of Email Address
@Feature: User - Positive Create
@Steps:
1. Create User for all valid Email Address variation in [1] using
valid Username, First Name, Surname, Language, authorized by
@Assert: User is created
"""
for email in valid_emails_list():
with self.subTest(email):
# The email must be escaped because some characters to not fail
# the parsing of the generated shell command
escaped_email = email.replace('"', r'\"').replace('`', r'\`')
user = make_user({'mail': escaped_email})
self.assertEqual(user['email'], email)
def test_positive_update_email_reply_address(setting_update):
"""Check email reply address is updated
:id: cb0907d1-9cb6-45c4-b2bb-e2790ea55f16
:parametrized: yes
:expectedresults: email_reply_address is updated
:CaseImportance: Low
:CaseAutomation: Automated
"""
email_address = random.choice(list(valid_emails_list()))
email_address = email_address.replace('"', r'\"').replace('`', r'\`')
Settings.set({'name': "email_reply_address", 'value': email_address})
email_reply_address = Settings.list({'search': 'name=email_reply_address'},
output_format='json')[0]
assert email_reply_address['value'] == email_address
def test_positive_update_email(self):
"""Update Email Address value for existing User
@Feature: User - Positive Update
@Assert: User is updated
"""
user = make_user()
for email in valid_emails_list():
with self.subTest(email):
User.update({
'id':
user['id'],
# escape to avoid bash syntax error
'mail':
email.replace('"', r'\"').replace('`', r'\`'),
})
result = User.info({'id': user['id']})
self.assertEqual(result['email'], email)
def test_filtered_datapoint_False(self):
"""Tests if run_one_datapoint=True returns one data point"""
settings.run_one_datapoint = True
self.assertEqual(len(generate_strings_list()), 1)
self.assertEqual(len(invalid_emails_list()), 1)
self.assertEqual(len(invalid_id_list()), 1)
self.assertEqual(len(invalid_interfaces_list()), 1)
self.assertEqual(len(invalid_names_list()), 1)
self.assertEqual(len(invalid_values_list()), 1)
self.assertEqual(len(valid_data_list()), 1)
self.assertEqual(len(valid_docker_repository_names()), 1)
self.assertEqual(len(valid_emails_list()), 1)
self.assertEqual(len(valid_environments_list()), 1)
self.assertEqual(len(valid_hosts_list()), 1)
self.assertEqual(len(valid_hostgroups_list()), 1)
self.assertEqual(len(valid_interfaces_list()), 1)
self.assertEqual(len(valid_labels_list()), 1)
self.assertEqual(len(valid_names_list()), 1)
self.assertEqual(len(valid_org_names_list()), 1)
self.assertEqual(len(valid_usernames_list()), 1)
def create_new_rhsso_user(client_id, username=None):
"""create new user in RHSSO instance and set the password"""
if not username:
username = gen_string('alphanumeric')
RHSSO_NEW_USER['username'] = username
RHSSO_NEW_USER['email'] = random.choice(valid_emails_list())
RHSSO_RESET_PASSWORD['value'] = rhsso_password
upload_rhsso_entity(RHSSO_NEW_USER, "create_user")
upload_rhsso_entity(RHSSO_RESET_PASSWORD, "reset_password")
run_command(
cmd=f"{KEY_CLOAK_CLI} create users -r {realm} -f create_user",
hostname=rhsso_host,
)
user_details = get_rhsso_user_details(RHSSO_NEW_USER['username'])
run_command(
cmd="{} update -r {} users/{}/reset-password -f {}".format(
KEY_CLOAK_CLI, realm, user_details['id'], "reset_password"),
hostname=rhsso_host,
)
return RHSSO_NEW_USER
def test_positive_update_email_reply_address(self):
"""Check email reply address is updated
:id: cb0907d1-9cb6-45c4-b2bb-e2790ea55f16
:expectedresults: email_reply_address is updated
:CaseImportance: Low
:CaseAutomation: automated
"""
for email in valid_emails_list():
with self.subTest(email):
# The email must be escaped because some characters to not fail
# the parsing of the generated shell command
escaped_email = email.replace('"', r'\"').replace('`', r'\`')
Settings.set({'name': "email_reply_address", 'value': escaped_email})
email_reply_address = Settings.list(
{'search': 'name=email_reply_address'}, output_format='json'
)[0]
self.assertEqual(email_reply_address['value'], email)
def test_return_type(self):
"""This test validates return types for functions:
1. :meth:`robottelo.datafactory.generate_strings_list`
2. :meth:`robottelo.datafactory.invalid_emails_list`
3. :meth:`robottelo.datafactory.invalid_names_list`
4. :meth:`robottelo.datafactory.valid_data_list`
5. :meth:`robottelo.datafactory.valid_emails_list`
6. :meth:`robottelo.datafactory.valid_environments_list`
7. :meth:`robottelo.datafactory.valid_hosts_list`
8. :meth:`robottelo.datafactory.valid_hostgroups_list`
9. :meth:`robottelo.datafactory.valid_labels_list`
10. :meth:`robottelo.datafactory.valid_names_list`
11. :meth:`robottelo.datafactory.valid_org_names_list`
12. :meth:`robottelo.datafactory.valid_usernames_list`
13. :meth:`robottelo.datafactory.invalid_id_list`
14. :meth:`robottelo.datafactory.invalid_interfaces_list`
15. :meth:`robottelo.datafactory.valid_interfaces_list`
"""
for item in itertools.chain(generate_strings_list(),
invalid_emails_list(),
invalid_interfaces_list(),
invalid_names_list(), valid_data_list(),
valid_emails_list(),
valid_environments_list(),
valid_hosts_list(),
valid_hostgroups_list(),
valid_interfaces_list(),
valid_labels_list(), valid_names_list(),
valid_org_names_list(),
valid_usernames_list()):
self.assertIsInstance(item, six.text_type)
for item in invalid_id_list():
if not (isinstance(item, (six.text_type, int)) or item is None):
self.fail('Unexpected data type')
def test_positive_update_email_reply_address(self):
"""Check email reply address is updated
:id: cb0907d1-9cb6-45c4-b2bb-e2790ea55f16
:expectedresults: email_reply_address is updated
:caseimportance: low
:caseautomation: automated
"""
for email in valid_emails_list():
with self.subTest(email):
# The email must be escaped because some characters to not fail
# the parsing of the generated shell command
escaped_email = email.replace(
'"', r'\"').replace('`', r'\`')
Settings.set({
'name': "email_reply_address",
'value': escaped_email})
email_reply_address = Settings.list({
'search': 'name=email_reply_address'
}, output_format='json')[0]
self.assertEqual(email_reply_address['value'], email)
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']})
class TestUser:
"""Tests for the ``users`` path."""
@pytest.mark.tier1
@pytest.mark.parametrize('username',
**parametrized(valid_usernames_list()))
def test_positive_create_with_username(self, username):
"""Create User for all variations of Username
:id: a9827cda-7f6d-4785-86ff-3b6969c9c00a
:parametrized: yes
:expectedresults: User is created
:CaseImportance: Critical
"""
user = entities.User(login=username).create()
assert user.login == username
@pytest.mark.tier1
@pytest.mark.parametrize('firstname',
**parametrized(
generate_strings_list(exclude_types=['html'],
max_length=50)))
def test_positive_create_with_firstname(self, firstname):
"""Create User for all variations of First Name
:id: 036bb958-227c-420c-8f2b-c607136f12e0
:parametrized: yes
:expectedresults: User is created
:CaseImportance: Critical
"""
if len(str.encode(firstname)) > 50:
firstname = firstname[:20]
user = entities.User(firstname=firstname).create()
assert user.firstname == firstname
@pytest.mark.tier1
@pytest.mark.parametrize('lastname',
**parametrized(
generate_strings_list(exclude_types=['html'],
max_length=50)))
def test_positive_create_with_lastname(self, lastname):
"""Create User for all variations of Last Name
:id: 95d3b571-77e7-42a1-9c48-21f242e8cdc2
:parametrized: yes
:expectedresults: User is created
:CaseImportance: Critical
"""
if len(str.encode(lastname)) > 50:
lastname = lastname[:20]
user = entities.User(lastname=lastname).create()
assert user.lastname == lastname
@pytest.mark.tier1
@pytest.mark.parametrize('mail', **parametrized(valid_emails_list()))
def test_positive_create_with_email(self, mail):
"""Create User for all variations of Email
:id: e68caf51-44ba-4d32-b79b-9ab9b67b9590
:parametrized: yes
:expectedresults: User is created
:CaseImportance: Critical
"""
user = entities.User(mail=mail).create()
assert user.mail == mail
@pytest.mark.tier1
@pytest.mark.parametrize('description', **parametrized(valid_data_list()))
def test_positive_create_with_description(self, description):
"""Create User for all variations of Description
:id: 1463d71c-b77d-4223-84fa-8370f77b3edf
:parametrized: yes
:expectedresults: User is created
:CaseImportance: Critical
"""
user = entities.User(description=description).create()
assert user.description == description
@pytest.mark.tier1
@pytest.mark.parametrize('password',
**parametrized(
generate_strings_list(exclude_types=['html'],
max_length=50)))
def test_positive_create_with_password(self, password):
"""Create User for all variations of Password
:id: 53d0a419-0730-4f7d-9170-d855adfc5070
:parametrized: yes
:expectedresults: User is created
:CaseImportance: Critical
"""
user = entities.User(password=password).create()
assert user is not None
@pytest.mark.tier1
@pytest.mark.upgrade
@pytest.mark.parametrize('mail', **parametrized(valid_emails_list()))
def test_positive_delete(self, mail):
"""Create random users and then delete it.
:id: df6059e7-85c5-42fa-99b5-b7f1ef809f52
:parametrized: yes
:expectedresults: The user cannot be fetched after deletion.
:CaseImportance: Critical
"""
user = entities.User(mail=mail).create()
user.delete()
with pytest.raises(HTTPError):
user.read()
@pytest.mark.tier1
@pytest.mark.parametrize('login', **parametrized(valid_usernames_list()))
def test_positive_update_username(self, create_user, login):
"""Update a user and provide new username.
:id: a8e218b1-7256-4f20-91f3-3958d58ea5a8
:parametrized: yes
:expectedresults: The user's ``Username`` attribute is updated.
:CaseImportance: Critical
"""
create_user.login = login
user = create_user.update(['login'])
assert user.login == login
@pytest.mark.tier1
@pytest.mark.parametrize('login', **parametrized(invalid_usernames_list()))
def test_negative_update_username(self, create_user, login):
"""Update a user and provide new login.
:id: 9eefcba6-66a3-41bf-87ba-3e032aee1db2
:parametrized: yes
:expectedresults: The user's ``login`` attribute is updated.
:CaseImportance: Critical
"""
with pytest.raises(HTTPError):
create_user.login = login
create_user.update(['login'])
@pytest.mark.tier1
@pytest.mark.parametrize('firstname',
**parametrized(
generate_strings_list(exclude_types=['html'],
max_length=50)))
def test_positive_update_firstname(self, create_user, firstname):
"""Update a user and provide new firstname.
:id: a1287d47-e7d8-4475-abe8-256e6f2034fc
:parametrized: yes
:expectedresults: The user's ``firstname`` attribute is updated.
:CaseImportance: Critical
"""
if len(str.encode(firstname)) > 50:
firstname = firstname[:20]
create_user.firstname = firstname
user = create_user.update(['firstname'])
assert user.firstname == firstname
@pytest.mark.tier1
@pytest.mark.parametrize('lastname',
**parametrized(
generate_strings_list(exclude_types=['html'],
max_length=50)))
def test_positive_update_lastname(self, create_user, lastname):
"""Update a user and provide new lastname.
:id: 25c6c9df-5db2-4827-89bb-b8fd0658a9b9
:parametrized: yes
:expectedresults: The user's ``lastname`` attribute is updated.
:CaseImportance: Critical
"""
if len(str.encode(lastname)) > 50:
lastname = lastname[:20]
create_user.lastname = lastname
user = create_user.update(['lastname'])
assert user.lastname == lastname
@pytest.mark.tier1
@pytest.mark.parametrize('mail', **parametrized(valid_emails_list()))
def test_positive_update_email(self, create_user, mail):
"""Update a user and provide new email.
:id: 3ae70631-7cee-4a4a-9c2f-b428273f1311
:parametrized: yes
:expectedresults: The user's ``mail`` attribute is updated.
:CaseImportance: Critical
"""
create_user.mail = mail
user = create_user.update(['mail'])
assert user.mail == mail
@pytest.mark.tier1
@pytest.mark.parametrize('mail', **parametrized(invalid_emails_list()))
def test_negative_update_email(self, create_user, mail):
"""Update a user and provide new email.
:id: 0631dce1-694c-4815-971d-26ff1934da98
:parametrized: yes
:expectedresults: The user's ``mail`` attribute is updated.
:CaseImportance: Critical
"""
with pytest.raises(HTTPError):
create_user.mail = mail
create_user.update(['mail'])
@pytest.mark.tier1
@pytest.mark.parametrize('description', **parametrized(valid_data_list()))
def test_positive_update_description(self, create_user, description):
"""Update a user and provide new email.
:id: a1d764ad-e9bb-4e5e-b8cd-3c52e1f128f6
:parametrized: yes
:expectedresults: The user's ``Description`` attribute is updated.
:CaseImportance: Critical
"""
create_user.description = description
user = create_user.update(['description'])
assert user.description == description
@pytest.mark.tier1
@pytest.mark.parametrize('admin_enable', [True, False])
def test_positive_update_admin(self, admin_enable):
"""Update a user and provide the ``admin`` attribute.
:id: b5fedf65-37f5-43ca-806a-ac9a7979b19d
:parametrized: yes
:expectedresults: The user's ``admin`` attribute is updated.
:CaseImportance: Critical
"""
user = entities.User(admin=admin_enable).create()
user.admin = not admin_enable
assert user.update().admin == (not admin_enable)
@pytest.mark.tier1
@pytest.mark.parametrize('mail', **parametrized(invalid_emails_list()))
def test_negative_create_with_invalid_email(self, mail):
"""Create User with invalid Email Address
:id: ebbd1f5f-e71f-41f4-a956-ce0071b0a21c
:parametrized: yes
:expectedresults: User is not created. Appropriate error shown.
:CaseImportance: Critical
"""
with pytest.raises(HTTPError):
entities.User(mail=mail).create()
@pytest.mark.tier1
@pytest.mark.parametrize('invalid_name',
**parametrized(invalid_usernames_list()))
def test_negative_create_with_invalid_username(self, invalid_name):
"""Create User with invalid Username
:id: aaf157a9-0375-4405-ad87-b13970e0609b
:parametrized: yes
:expectedresults: User is not created. Appropriate error shown.
:CaseImportance: Critical
"""
with pytest.raises(HTTPError):
entities.User(login=invalid_name).create()
@pytest.mark.tier1
@pytest.mark.parametrize('invalid_name',
**parametrized(invalid_names_list()))
def test_negative_create_with_invalid_firstname(self, invalid_name):
"""Create User with invalid Firstname
:id: cb1ca8a9-38b1-4d58-ae32-915b47b91657
:parametrized: yes
:expectedresults: User is not created. Appropriate error shown.
:CaseImportance: Critical
"""
with pytest.raises(HTTPError):
entities.User(firstname=invalid_name).create()
@pytest.mark.tier1
@pytest.mark.parametrize('invalid_name',
**parametrized(invalid_names_list()))
def test_negative_create_with_invalid_lastname(self, invalid_name):
"""Create User with invalid Lastname
:id: 59546d26-2b6b-400b-990f-0b5d1c35004e
:parametrized: yes
:expectedresults: User is not created. Appropriate error shown.
:CaseImportance: Critical
"""
with pytest.raises(HTTPError):
entities.User(lastname=invalid_name).create()
@pytest.mark.tier1
def test_negative_create_with_blank_authorized_by(self):
"""Create User with blank authorized by
:id: 1fe2d1e3-728c-4d89-97ae-3890e904f413
:expectedresults: User is not created. Appropriate error shown.
:CaseImportance: Critical
"""
with pytest.raises(HTTPError):
entities.User(auth_source='').create()
