def tearDownClass(cls):
super(BruteForceLogin, cls).tearDownClass()
# reset failed_login_attempts_limit value
sleep(301)
Settings.set({
u'name': u'failed_login_attempts_limit',
u'value': cls.host_value})
def test_positive_update_hostname_prefix_without_value(self):
"""Update the Hostname_prefix settings without any string(empty values)
:id: a84c28ea-6821-4c31-b4ab-8662c22c9135
:expectedresults: Hostname_prefix should be set without any text
"""
Settings.set({'name': "discovery_prefix", 'value': ""})
discovery_prefix = Settings.list({
'search': 'name=discovery_prefix'
})[0]
self.assertEqual('', discovery_prefix['value'])
def setUp(self):
"""Create a directory for export, configure permissions and satellite
settings
"""
super(RepositoryExportTestCase, self).setUp()
if not RepositoryExportTestCase.is_set_up:
RepositoryExportTestCase.export_dir = gen_string('alphanumeric')
# Create a new 'export' directory on the Satellite system
result = ssh.command('mkdir /mnt/{0}'.format(self.export_dir))
self.assertEqual(result.return_code, 0)
result = ssh.command(
'chown foreman.foreman /mnt/{0}'.format(self.export_dir))
self.assertEqual(result.return_code, 0)
result = ssh.command(
'ls -Z /mnt/ | grep {0}'.format(self.export_dir))
self.assertEqual(result.return_code, 0)
self.assertGreaterEqual(len(result.stdout), 1)
self.assertIn('unconfined_u:object_r:mnt_t:s0', result.stdout[0])
# Fix SELinux policy for new directory
result = ssh.command(
'semanage fcontext -a -t foreman_var_run_t "/mnt/{0}(/.*)?"'
.format(self.export_dir)
)
self.assertEqual(result.return_code, 0)
result = ssh.command(
'restorecon -Rv /mnt/{0}'.format(self.export_dir))
self.assertEqual(result.return_code, 0)
# Assert that we have the correct policy
result = ssh.command(
'ls -Z /mnt/ | grep {0}'.format(self.export_dir))
self.assertEqual(result.return_code, 0)
self.assertGreaterEqual(len(result.stdout), 1)
self.assertIn(
'unconfined_u:object_r:foreman_var_run_t:s0', result.stdout[0])
# Update the 'pulp_export_destination' settings to new directory
Settings.set({
'name': 'pulp_export_destination',
'value': '/mnt/{0}'.format(self.export_dir),
})
# Create an organization to reuse in tests
RepositoryExportTestCase.org = make_org()
RepositoryExportTestCase.is_set_up = True
def test_positive_session_preceeds_saved_credentials(self):
"""Check if enabled session is mutually exclusive with
saved credentials in hammer config
:id: e4277298-1c24-494b-84a6-22f45f96e144
:BZ: 1471099
:Steps:
1. Set use_sessions, set usernam and password,
set short expiration time
2. Authenticate, assert credentials are not demanded
on next command run
3. Wait until session expires
:expectedresults: Session expires after specified time
and saved credentials are not applied
"""
try:
idle_timeout = Settings.list({
'search': 'name=idle_timeout'})[0][u'value']
Settings.set({'name': 'idle_timeout', 'value': 1})
result = configure_sessions(add_default_creds=True)
self.assertEqual(result, 0, 'Failed to configure hammer sessions')
Auth.login({
'username': self.uname_admin,
'password': self.password
})
result = Auth.with_user().status()
self.assertIn(
LOGEDIN_MSG.format(self.uname_admin),
result[0][u'message']
)
# list organizations without supplying credentials
with self.assertNotRaises(CLIReturnCodeError):
Org.with_user().list()
# wait until session expires
sleep(70)
with self.assertRaises(CLIReturnCodeError):
Org.with_user().list()
result = Auth.with_user().status()
self.assertIn(
LOGEDOFF_MSG.format(self.uname_admin),
result[0][u'message']
)
finally:
# reset timeout to default
Settings.set({'name': 'idle_timeout', 'value': '{}'.format(
idle_timeout)})
def test_negative_update_send_welcome_email(value):
"""Check email send welcome email is updated
:id: 2f75775d-72a1-4b2f-86c2-98c36e446099
:steps: set invalid values: not booleans
:expectedresults: send_welcome_email is not updated
:caseautomation: automated
:caseimportance: low
"""
with pytest.raises(CLIReturnCodeError):
Settings.set({'name': 'send_welcome_email', 'value': value})
def test_positive_update_login_page_footer_text_without_value(self):
"""Updates parameter "login_text" without any string (empty value)
:id: 01ce95de-2994-42b6-b9f8-f7882981fb69
:steps:
1. Execute "settings" command with "set" as sub-command
without any string(empty value) in value parameter
:expectedresults: Message on login screen should be removed
"""
Settings.set({'name': "login_text", 'value': ""})
login_text = Settings.list({'search': 'name=login_text'})[0]
self.assertEqual('', login_text['value'])
def test_positive_update_hostname_default_prefix(self):
"""Update the default set prefix of hostname_prefix setting
:id: a6e46e53-6273-406a-8009-f184d9551d66
:expectedresults: Default set prefix should be updated with new value
"""
hostname_prefix_value = gen_string('alpha')
Settings.set({
'name': "discovery_prefix",
'value': hostname_prefix_value
})
discovery_prefix = Settings.list({
'search': 'name=discovery_prefix'
})[0]
self.assertEqual(hostname_prefix_value, discovery_prefix['value'])
def test_positive_create_session(self):
"""Check if user stays authenticated with session enabled
:id: fcee7f5f-1040-41a9-bf17-6d0c24a93e22
:Steps:
1. Set use_sessions, set short expiration time
2. Authenticate, assert credentials are not demanded
on next command run
3. Wait until session expires, assert credentials
are required
:expectedresults: The session is successfully created and
expires after specified time
"""
try:
idle_timeout = Settings.list({
'search': 'name=idle_timeout'})[0][u'value']
Settings.set({'name': 'idle_timeout', 'value': 1})
result = configure_sessions()
self.assertEqual(result, 0, 'Failed to configure hammer sessions')
Auth.login({
'username': self.uname_admin,
'password': self.password
})
result = Auth.with_user().status()
self.assertIn(
LOGEDIN_MSG.format(self.uname_admin),
result[0][u'message']
)
# list organizations without supplying credentials
with self.assertNotRaises(CLIReturnCodeError):
Org.with_user().list()
# wait until session expires
sleep(70)
with self.assertRaises(CLIReturnCodeError):
Org.with_user().list()
result = Auth.with_user().status()
self.assertIn(
LOGEDOFF_MSG.format(self.uname_admin),
result[0][u'message']
)
finally:
# reset timeout to default
Settings.set({'name': 'idle_timeout', 'value': '{}'.format(
idle_timeout)})
def test_positive_enable_disable_rssfeed(self):
"""Check if the RSS feed can be enabled or disabled
:id: 021cefab-2629-44e2-a30d-49c944d0a234
:steps: Set rss_enable true or false
:expectedresults: rss_enable is updated
:caseautomation: automated
"""
orig_value = Settings.list({'search': 'name=rss_enable'})[0]['value']
for value in ['true', 'false']:
Settings.set({'name': 'rss_enable', 'value': value})
rss_setting = Settings.list({'search': 'name=rss_enable'})[0]
self.assertEqual(value, rss_setting['value'])
Settings.set({'name': 'rss_enable', 'value': orig_value})
def test_positive_update_login_page_footer_text(self):
"""Updates parameter "login_text" in settings
:id: 4d4e1151-5bd6-4fa2-8dbb-e182b43ad7ec
:steps:
1. Execute "settings" command with "set" as sub-command
with any string
:expectedresults: Parameter is updated successfully
"""
for login_text_value in valid_data_list():
with self.subTest(login_text_value):
Settings.set({'name': "login_text", 'value': login_text_value})
login_text = Settings.list({'search': 'name=login_text'})[0]
self.assertEqual(login_text_value, login_text['value'])
def test_positive_update_send_welcome_email(self):
"""Check email send welcome email is updated
:id: cdaf6cd0-5eea-4252-87c5-f9ec3ba79ac1
:steps: valid values: boolean true or false
:expectedresults: send_welcome_email is updated
:caseautomation: automated
:caseimportance: low
"""
for value in ['true', 'false']:
Settings.set({'name': 'send_welcome_email', 'value': value})
host_value = Settings.list(
{'search': 'name=send_welcome_email'})[0]['value']
assert value == host_value
def test_positive_update_login_page_footer_text_with_long_string(self):
"""Attempt to update parameter "Login_page_footer_text"
with long length string under General tab
:id: 87ef6b19-fdc5-4541-aba8-e730f1a3caa7
:steps:
1. Execute "settings" command with "set" as sub-command
with long length string
:expectedresults: Parameter is updated
:caseimportance: low
"""
for login_text_value in generate_strings_list(1000):
with self.subTest(login_text_value):
Settings.set({'name': "login_text", 'value': login_text_value})
login_text = Settings.list({'search': 'name=login_text'})[0]
self.assertEqual(login_text_value, login_text['value'])
def test_negative_update_email_reply_address(self):
"""Check email reply address is not updated
:id: 2a2220c2-badf-47d5-ba3f-e6329930ab39
:steps: provide invalid email addresses
:expectedresults: email_reply_address is not updated
:caseimportance: low
:caseautomation: automated
"""
for email in invalid_emails_list():
with self.subTest(email):
with self.assertRaises(CLIReturnCodeError):
Settings.set({
'name': 'email_reply_address',
'value': email
})
def test_positive_update_login_page_footer_text_with_long_string(
setting_update):
"""Attempt to update parameter "Login_page_footer_text"
with long length string under General tab
:id: 87ef6b19-fdc5-4541-aba8-e730f1a3caa7
:steps:
1. Execute "settings" command with "set" as sub-command
with long length string
:parametrized: yes
:expectedresults: Parameter is updated
:CaseImportance: Low
"""
login_text_value = random.choice(list(generate_strings_list(1000)))
Settings.set({'name': "login_text", 'value': login_text_value})
login_text = Settings.list({'search': 'name=login_text'})[0]
assert login_text['value'] == login_text_value
def test_positive_update_rssfeed_url(self):
"""Check if the RSS feed URL is updated
:id: 166ff6f2-e36e-4934-951f-b947139d0d73
:steps:
1. Save the original RSS URL
2. Update RSS feed with a valid URL
3. Assert the RSS feed URL was really updated
4. Restore the original feed URL
:expectedresults: RSS feed URL is updated
:caseautomation: automated
"""
orig_url = Settings.list({'search': 'name=rss_url'})[0]['value']
for test_url in valid_url_list():
Settings.set({'name': 'rss_url', 'value': test_url})
updated_url = Settings.list({'search': 'name=rss_url'})[0]
self.assertEqual(test_url, updated_url['value'])
Settings.set({'name': 'rss_url', 'value': orig_url})
def test_negative_update_email_subject_prefix(setting_update):
"""Check email subject prefix is not updated
:id: 8a638596-248f-4196-af36-ad2982196382
:parametrized: yes
:steps: provide invalid prefix, like string with more than 255 chars
:expectedresults: email_subject_prefix is not updated
:CaseAutomation: Automated
:CaseImportance: Low
"""
email_subject_prefix_original = Settings.list({'search': 'name=email_subject_prefix'})[0]
email_subject_prefix_value = gen_string('alpha', 256)
with pytest.raises(CLIReturnCodeError):
Settings.set({'name': 'email_subject_prefix', 'value': email_subject_prefix_value})
email_subject_prefix = Settings.list({'search': 'name=email_subject_prefix'})[0]
assert email_subject_prefix == email_subject_prefix_original
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_update_rssfeed_url(self):
"""Check if the RSS feed URL is updated
:id: 166ff6f2-e36e-4934-951f-b947139d0d73
:steps:
1. Save the original RSS URL
2. Update RSS feed with a valid URL
3. Assert the RSS feed URL was really updated
4. Restore the original feed URL
:expectedresults: RSS feed URL is updated
:CaseAutomation: automated
"""
orig_url = Settings.list({'search': 'name=rss_url'})[0]['value']
for test_url in valid_url_list():
Settings.set({'name': 'rss_url', 'value': test_url})
updated_url = Settings.list({'search': 'name=rss_url'})[0]
self.assertEqual(test_url, updated_url['value'])
Settings.set({'name': 'rss_url', 'value': orig_url})
def test_negative_update_email_reply_address(setting_update):
"""Check email reply address is not updated
:id: 2a2220c2-badf-47d5-ba3f-e6329930ab39
:steps: provide invalid email addresses
:parametrized: yes
:expectedresults: email_reply_address is not updated
:CaseImportance: Low
:CaseAutomation: Automated
"""
invalid_email_address = random.choice(list(invalid_emails_list()))
with pytest.raises(CLIReturnCodeError):
Settings.set({
'name': 'email_reply_address',
'value': invalid_email_address
})
def test_positive_update_email_subject_prefix(setting_update):
"""Check email subject prefix is updated
:id: c8e6b323-7b39-43d6-a9f1-5474f920bba2
:parametrized: yes
:expectedresults: email_subject_prefix is updated
:CaseAutomation: Automated
:CaseImportance: Low
"""
email_subject_prefix_value = gen_string('alpha')
Settings.set({
'name': "email_subject_prefix",
'value': email_subject_prefix_value
})
email_subject_prefix = Settings.list(
{'search': 'name=email_subject_prefix'})[0]
assert email_subject_prefix_value == email_subject_prefix['value']
def test_positive_update_rssfeed_url(setting_update):
"""Check if the RSS feed URL is updated
:id: 166ff6f2-e36e-4934-951f-b947139d0d73
:steps:
1. Save the original RSS URL
2. Update RSS feed with a valid URL
3. Assert the RSS feed URL was really updated
4. Restore the original feed URL
:parametrized: yes
:expectedresults: RSS feed URL is updated
:CaseAutomation: Automated
"""
test_url = random.choice(list(valid_url_list()))
Settings.set({'name': 'rss_url', 'value': test_url})
updated_url = Settings.list({'search': 'name=rss_url'})[0]
assert updated_url['value'] == test_url
def test_positive_session_preceeds_saved_credentials(self):
"""Check if enabled session is mutually exclusive with
saved credentials in hammer config
:id: e4277298-1c24-494b-84a6-22f45f96e144
:BZ: 1471099
:Steps:
1. Set use_sessions, set usernam and password,
set short expiration time
2. Authenticate, assert credentials are not demanded
on next command run
3. Wait until session expires
:expectedresults: Session expires after specified time
and saved credentials are not applied
"""
try:
idle_timeout = Settings.list({'search': 'name=idle_timeout'})[0]['value']
Settings.set({'name': 'idle_timeout', 'value': 1})
result = configure_sessions(add_default_creds=True)
self.assertEqual(result, 0, 'Failed to configure hammer sessions')
AuthLogin.basic({'username': self.uname_admin, 'password': self.password})
result = Auth.with_user().status()
self.assertIn(LOGEDIN_MSG.format(self.uname_admin), result[0]['message'])
# list organizations without supplying credentials
with self.assertNotRaises(CLIReturnCodeError):
Org.with_user().list()
# wait until session expires
sleep(70)
with self.assertRaises(CLIReturnCodeError):
Org.with_user().list()
result = Auth.with_user().status()
self.assertIn(LOGEDOFF_MSG.format(self.uname_admin), result[0]['message'])
finally:
# reset timeout to default
Settings.set({'name': 'idle_timeout', 'value': '{}'.format(idle_timeout)})
def test_positive_failed_login_attempts_limit(setting_update):
"""automate brute force protection limit configurable function
:id: f95407ed-451b-4387-ac9b-2959ae2f51ae
:steps:
1. Make sure login works.
2. Save current value and set it to some lower value:
3. Try to login with wrong password till failed_login_attempts_limit
4. Make sure login now does not work:
5. Wait timeout - 5 minutes + 1 second
6. Verify you can now login fine
7. Return the setting to previous value
:CaseImportance: Critical
:CaseLevel: System
:parametrized: yes
:expectedresults: failed_login_attempts_limit works as expected
:CaseAutomation: Automated
:BZ: 1778599
"""
username = settings.server.admin_username
password = settings.server.admin_password
result = ssh.command(f'hammer -u {username} -p {password} user list')
assert result.return_code == 0
Settings.set({'name': 'failed_login_attempts_limit', 'value': '5'})
for i in range(5):
output = ssh.command(f'hammer -u {username} -p BAD_PASS user list')
assert output.return_code == 129
result = ssh.command(f'hammer -u {username} -p {password} user list')
assert result.return_code == 129
sleep(301)
result = ssh.command(f'hammer -u {username} -p {password} user list')
assert result.return_code == 0
def test_positive_failed_login_attempts_limit(self):
"""automate brute force protection limit configurable function
:id: f95407ed-451b-4387-ac9b-2959ae2f51ae
:steps:
1. Make sure login works.
2. Save current value and set it to some lower value:
3. Try to login with wrong password till failed_login_attempts_limit
4. Make sure login now does not work:
5. Wait timeout - 5 minutes + 1 second
6. Verify you can now login fine
7. Return the setting to previous value
:expectedresults: failed_login_attempts_limit works as expected
:caseautomation: automated
"""
result = ssh.command(
'hammer -u {0} -p {1} user list'
.format(self.foreman_user, self.foreman_password))
self.assertEqual(result.return_code, 0)
Settings.set({
u'name': u'failed_login_attempts_limit',
u'value': '5'
})
for i in range(5):
output = ssh.command(
'hammer -u {0} -p BAD_PASS user list'.format(
self.foreman_user))
self.assertEqual(output.return_code, 129)
result = ssh.command(
'hammer -u {0} -p {1} user list'
.format(self.foreman_user, self.foreman_password))
self.assertEqual(result.return_code, 129)
sleep(301)
result = ssh.command(
'hammer -u {0} -p {1} user list'
.format(self.foreman_user, self.foreman_password))
self.assertEqual(result.return_code, 0)
def test_positive_create_session(admin_user, target_sat):
"""Check if user stays authenticated with session enabled
:id: fcee7f5f-1040-41a9-bf17-6d0c24a93e22
:Steps:
1. Set use_sessions, set short expiration time
2. Authenticate, assert credentials are not demanded
on next command run
3. Wait until session expires, assert credentials
are required
:expectedresults: The session is successfully created and
expires after specified time
"""
try:
idle_timeout = Settings.list({'search':
'name=idle_timeout'})[0]['value']
Settings.set({'name': 'idle_timeout', 'value': 1})
result = configure_sessions(target_sat)
assert result == 0, 'Failed to configure hammer sessions'
AuthLogin.basic({
'username': admin_user['login'],
'password': password
})
result = Auth.with_user().status()
assert LOGEDIN_MSG.format(admin_user['login']) in result[0]['message']
# list organizations without supplying credentials
assert Org.with_user().list()
# wait until session expires
sleep(70)
with pytest.raises(CLIReturnCodeError):
Org.with_user().list()
result = Auth.with_user().status()
assert LOGEDOFF_MSG.format(admin_user['login']) in result[0]['message']
finally:
# reset timeout to default
Settings.set({'name': 'idle_timeout', 'value': f'{idle_timeout}'})
def tearDownClass(cls):
"""Restore default global setting's values"""
Settings.set({'name': 'discovery_location', 'value': cls.default_discovery_loc['value']})
Settings.set(
{'name': 'discovery_organization', 'value': cls.default_discovery_org['value']}
)
Settings.set({'name': 'discovery_auto', 'value': cls.default_discovery_auto['value']})
super().tearDownClass()
def test_positive_update_email_subject_prefix(self):
"""Check email subject prefix is updated
:id: c8e6b323-7b39-43d6-a9f1-5474f920bba2
:expectedresults: email_subject_prefix is updated
:caseautomation: automated
:caseimportance: low
"""
email_subject_prefix_value = gen_string('alpha')
Settings.set({
'name': "email_subject_prefix",
'value': email_subject_prefix_value
})
email_subject_prefix = Settings.list({
'search': 'name=email_subject_prefix'
})[0]
self.assertEqual(
email_subject_prefix_value,
email_subject_prefix['value']
)
def test_positive_update_send_welcome_email(setting_update,
send_welcome_email_value):
"""Check email send welcome email is updated
:id: cdaf6cd0-5eea-4252-87c5-f9ec3ba79ac1
:steps: valid values: boolean true or false
:parametrized: yes
:expectedresults: send_welcome_email is updated
:CaseAutomation: Automated
:CaseImportance: Low
"""
Settings.set({
'name': 'send_welcome_email',
'value': send_welcome_email_value
})
host_value = Settings.list({'search':
'name=send_welcome_email'})[0]['value']
assert send_welcome_email_value == host_value
def test_positive_update_email_subject_prefix(self):
"""Check email subject prefix is updated
:id: c8e6b323-7b39-43d6-a9f1-5474f920bba2
:expectedresults: email_subject_prefix is updated
:caseautomation: automated
:caseimportance: low
"""
email_subject_prefix_value = gen_string('alpha')
Settings.set({
'name': "email_subject_prefix",
'value': email_subject_prefix_value
})
email_subject_prefix = Settings.list({
'search': 'name=email_subject_prefix'
})[0]
self.assertEqual(
email_subject_prefix_value,
email_subject_prefix['value']
)
def test_positive_failed_login_attempts_limit(self):
"""automate brute force protection limit configurable function
:id: f95407ed-451b-4387-ac9b-2959ae2f51ae
:steps:
1. Make sure login works.
2. Save current value and set it to some lower value:
3. Try to login with wrong password till failed_login_attempts_limit
4. Make sure login now does not work:
5. Wait timeout - 5 minutes + 1 second
6. Verify you can now login fine
7. Return the setting to previous value
:CaseImportance: Critical
:CaseLevel: System
:expectedresults: failed_login_attempts_limit works as expected
:CaseAutomation: automated
"""
result = ssh.command('hammer -u {0} -p {1} user list'.format(
self.foreman_user, self.foreman_password))
self.assertEqual(result.return_code, 0)
Settings.set({u'name': u'failed_login_attempts_limit', u'value': '5'})
for i in range(5):
output = ssh.command('hammer -u {0} -p BAD_PASS user list'.format(
self.foreman_user))
self.assertEqual(output.return_code, 129)
result = ssh.command('hammer -u {0} -p {1} user list'.format(
self.foreman_user, self.foreman_password))
self.assertEqual(result.return_code, 129)
sleep(301)
result = ssh.command('hammer -u {0} -p {1} user list'.format(
self.foreman_user, self.foreman_password))
self.assertEqual(result.return_code, 0)
def test_positive_create_session(self):
"""Check if user stays authenticated with session enabled
:id: fcee7f5f-1040-41a9-bf17-6d0c24a93e22
:Steps:
1. Set use_sessions, set short expiration time
2. Authenticate, assert credentials are not demanded
on next command run
3. Wait until session expires, assert credentials
are required
:expectedresults: The session is successfully created and
expires after specified time
"""
try:
idle_timeout = Settings.list({'search': 'name=idle_timeout'})[0]['value']
Settings.set({'name': 'idle_timeout', 'value': 1})
result = configure_sessions()
self.assertEqual(result, 0, 'Failed to configure hammer sessions')
AuthLogin.basic({'username': self.uname_admin, 'password': self.password})
result = Auth.with_user().status()
self.assertIn(LOGEDIN_MSG.format(self.uname_admin), result[0]['message'])
# list organizations without supplying credentials
with self.assertNotRaises(CLIReturnCodeError):
Org.with_user().list()
# wait until session expires
sleep(70)
with self.assertRaises(CLIReturnCodeError):
Org.with_user().list()
result = Auth.with_user().status()
self.assertIn(LOGEDOFF_MSG.format(self.uname_admin), result[0]['message'])
finally:
# reset timeout to default
Settings.set({'name': 'idle_timeout', 'value': '{}'.format(idle_timeout)})
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 setUpClass(cls):
"""Steps to Configure foreman discovery
1. Build PXE default template
2. Create Organization/Location
3. Update Global parameters to set default org and location for
discovered hosts.
4. Enable auto_provision flag to perform discovery via discovery
rules.
"""
super(DiscoveredTestCase, cls).setUpClass()
# Build PXE default template to get default PXE file
Template.build_pxe_default()
# let's just modify the timeouts to speed things up
ssh.command("sed -ie 's/TIMEOUT [[:digit:]]\\+/TIMEOUT 1/g' "
"/var/lib/tftpboot/pxelinux.cfg/default")
ssh.command("sed -ie '/APPEND initrd/s/$/ fdi.countdown=1/' "
"/var/lib/tftpboot/pxelinux.cfg/default")
# Create Org and location
cls.org = make_org()
cls.loc = make_location()
# Get default settings values
cls.default_discovery_loc = Settings.list(
{'search': 'name=%s' % 'discovery_location'})[0]
cls.default_discovery_org = Settings.list(
{'search': 'name=%s' % 'discovery_organization'})[0]
cls.default_discovery_auto = Settings.list(
{'search': 'name=%s' % 'discovery_auto'})[0]
# Update default org and location params to place discovered host
Settings.set({'name': 'discovery_location', 'value': cls.loc['name']})
Settings.set({
'name': 'discovery_organization',
'value': cls.org['name']
})
# Enable flag to auto provision discovered hosts via discovery rules
Settings.set({'name': 'discovery_auto', 'value': 'true'})
# Flag which shows whether environment is fully configured for
# discovered host provisioning.
cls.configured_env = False
if bz_bug_is_open(1578290):
ssh.command('mkdir /var/lib/tftpboot/boot/fdi-image')
ssh.command('ln -s /var/lib/tftpboot/boot/'
'foreman-discovery-image-3.4.4-1.iso-vmlinuz'
' /var/lib/tftpboot/boot/fdi-image/vmlinuz0')
ssh.command('ln -s /var/lib/tftpboot/boot/'
'foreman-discovery-image-3.4.4-1.iso-img'
' /var/lib/tftpboot/boot/fdi-image/initrd0.img')
ssh.command('chown -R foreman-proxy /var/lib/tftpboot/boot/')
def setUpClass(cls):
"""Steps to Configure foreman discovery
1. Build PXE default template
2. Create Organization/Location
3. Update Global parameters to set default org and location for
discovered hosts.
4. Enable auto_provision flag to perform discovery via discovery
rules.
"""
super(DiscoveredTestCase, cls).setUpClass()
# Build PXE default template to get default PXE file
Template.build_pxe_default()
# let's just modify the timeouts to speed things up
ssh.command("sed -ie 's/TIMEOUT [[:digit:]]\\+/TIMEOUT 1/g' "
"/var/lib/tftpboot/pxelinux.cfg/default")
ssh.command("sed -ie '/APPEND initrd/s/$/ fdi.countdown=1/' "
"/var/lib/tftpboot/pxelinux.cfg/default")
# Create Org and location
cls.org = make_org()
cls.loc = make_location()
# Get default settings values
cls.default_discovery_loc = Settings.list(
{'search': 'name=%s' % 'discovery_location'})[0]
cls.default_discovery_org = Settings.list(
{'search': 'name=%s' % 'discovery_organization'})[0]
cls.default_discovery_auto = Settings.list(
{'search': 'name=%s' % 'discovery_auto'})[0]
# Update default org and location params to place discovered host
Settings.set({'name': 'discovery_location', 'value': cls.loc['name']})
Settings.set(
{'name': 'discovery_organization', 'value': cls.org['name']})
# Enable flag to auto provision discovered hosts via discovery rules
Settings.set({'name': 'discovery_auto', 'value': 'true'})
# Flag which shows whether environment is fully configured for
# discovered host provisioning.
cls.configured_env = False
if bz_bug_is_open(1578290):
ssh.command('mkdir /var/lib/tftpboot/boot/fdi-image')
ssh.command('ln -s /var/lib/tftpboot/boot/'
'foreman-discovery-image-3.4.4-1.iso-vmlinuz'
' /var/lib/tftpboot/boot/fdi-image/vmlinuz0')
ssh.command('ln -s /var/lib/tftpboot/boot/'
'foreman-discovery-image-3.4.4-1.iso-img'
' /var/lib/tftpboot/boot/fdi-image/initrd0.img')
ssh.command('chown -R foreman-proxy /var/lib/tftpboot/boot/')
def test_positive_set_content_default_http_proxy(block_fake_repo_access):
"""An http proxy can be set to be the global default for repositories.
:id: c12868eb-98f1-4763-a168-281ac44d9ff5
:Steps:
1. Create a product with repo.
2. Create an un-authenticated proxy.
3. Set the proxy to be the global default proxy.
4. Sync a repo.
:expectedresults: Repo is synced
:CaseImportance: High
"""
org = entities.Organization().create()
proxy_name = gen_string('alpha', 15)
proxy_url = settings.http_proxy.un_auth_proxy_url
product = entities.Product(organization=org).create()
rpm_repo = entities.Repository(product=product,
content_type='yum',
url=settings.repos.yum_1.url).create()
# Create un-auth HTTP proxy
http_proxy = HttpProxy.create({
'name': proxy_name,
'url': proxy_url,
'organization-id': org.id,
})
assert http_proxy['name'] == proxy_name
assert http_proxy['url'] == proxy_url
# Set the proxy to be the global default
proxy_settings = Settings.set({
'name': 'content_default_http_proxy',
'value': proxy_name,
})
assert proxy_settings
# Sync to check proxy works
assert rpm_repo.read().content_counts['rpm'] == 0
product.sync()
assert rpm_repo.read().content_counts['rpm'] >= 1
def tearDownClass(cls):
"""Restore default global setting's values"""
Settings.set({
'name': 'discovery_location',
'value': cls.default_discovery_loc['value']
})
Settings.set({
'name': 'discovery_organization',
'value': cls.default_discovery_org['value']
})
Settings.set({
'name': 'discovery_auto',
'value': cls.default_discovery_auto['value']
})
super(DiscoveredTestCase, cls).tearDownClass()
def setUpClass(cls):
"""Steps to Configure foreman discovery
1. Build PXE default template
2. Create Organization/Location
3. Update Global parameters to set default org and location for
discovered hosts.
4. Enable auto_provision flag to perform discovery via discovery
rules.
"""
super(DiscoveredTestCase, cls).setUpClass()
# Build PXE default template to get default PXE file
Template.build_pxe_default()
# Create Org and location
cls.org = make_org()
cls.loc = make_location()
# Get default settings values
cls.default_discovery_loc = Settings.list(
{'search': 'name=%s' % 'discovery_location'})[0]
cls.default_discovery_org = Settings.list(
{'search': 'name=%s' % 'discovery_organization'})[0]
cls.default_discovery_auto = Settings.list(
{'search': 'name=%s' % 'discovery_auto'})[0]
# Update default org and location params to place discovered host
Settings.set({'name': 'discovery_location', 'value': cls.loc['name']})
Settings.set({
'name': 'discovery_organization',
'value': cls.org['name']
})
# Enable flag to auto provision discovered hosts via discovery rules
Settings.set({'name': 'discovery_auto', 'value': 'true'})
# Flag which shows whether environment is fully configured for
# discovered host provisioning.
cls.configured_env = False
def setUpClass(cls):
"""Steps to Configure foreman discovery
1. Build PXE default template
2. Create Organization/Location
3. Update Global parameters to set default org and location for
discovered hosts.
4. Enable auto_provision flag to perform discovery via discovery
rules.
"""
super(DiscoveredTestCase, cls).setUpClass()
# Build PXE default template to get default PXE file
Template.build_pxe_default()
# Create Org and location
cls.org = make_org()
cls.loc = make_location()
# Get default settings values
cls.default_discovery_loc = Settings.list(
{'search': 'name=%s' % 'discovery_location'})[0]
cls.default_discovery_org = Settings.list(
{'search': 'name=%s' % 'discovery_organization'})[0]
cls.default_discovery_auto = Settings.list(
{'search': 'name=%s' % 'discovery_auto'})[0]
# Update default org and location params to place discovered host
Settings.set({'name': 'discovery_location', 'value': cls.loc['name']})
Settings.set(
{'name': 'discovery_organization', 'value': cls.org['name']})
# Enable flag to auto provision discovered hosts via discovery rules
Settings.set({'name': 'discovery_auto', 'value': 'true'})
# Flag which shows whether environment is fully configured for
# discovered host provisioning.
cls.configured_env = False
def tearDownClass(cls):
super(BruteForceLogin, cls).tearDownClass()
# reset failed_login_attempts_limit value
sleep(301)
Settings.set({'name': 'failed_login_attempts_limit', 'value': cls.host_value})
def test_positive_provision_rhev_image_based(provisioning, rhev, tear_down, setting_update):
"""Provision a host on RHEV compute resource using image-based provisioning
:Requirement: Computeresource RHV
:CaseComponent: ComputeResources-RHEV
:Assignee: lhellebr
:id: ba78858f-5cff-462e-a35d-f5aa4d11db52
:setup: RHEV with a template on it
:steps:
1. Create a RHEV CR
1. Create an image on that CR
2. Create a new host using that CR and image
:expectedresults: The host should be provisioned with that image
:CaseAutomation: Automated
"""
try:
name = gen_string('alpha')
rhv_cr = ComputeResource.create(
{
'name': name,
'provider': 'Ovirt',
'user': rhev.username,
'password': rhev.password,
'datacenter': rhev.datacenter,
'url': rhev.hostname,
'ovirt-quota': rhev.quota,
'organizations': provisioning.org_name,
'locations': provisioning.loc_name,
}
)
assert rhv_cr['name'] == name
host_name = gen_string('alpha').lower()
# use some RHEL (usually latest)
os = (
entities.OperatingSystem()
.search(
query={
'search': f'name="RedHat" AND (major="{RHEL_6_MAJOR_VERSION}" OR '
f'major="{RHEL_7_MAJOR_VERSION}")'
}
)[0]
.read()
)
image = ComputeResource.image_create(
{
'compute-resource': rhv_cr['name'],
'name': f'img {gen_string(str_type="alpha")}',
'uuid': rhev.image_uuid,
'operatingsystem-id': os.id,
'architecture': rhev.image_arch,
'username': '******',
'password': rhev.image_password,
'user-data': 'yes', # so finish template won't be used
}
)
host = make_host(
{
'name': f'{host_name}',
'organization': provisioning.org_name,
'domain': provisioning.config_env['domain'],
'subnet': provisioning.config_env['subnet'],
'location': provisioning.loc_name,
'compute-resource-id': rhv_cr.get('id'),
'compute-attributes': f"cluster={rhev.cluster_id},"
"cores=1,"
"memory=1073741824,"
"start=0",
'ip': None,
'mac': None,
'interface': f"compute_name=nic1, compute_network={rhev.network_id}",
'provision-method': 'image',
'operatingsystem-id': os.id,
'architecture': rhev.image_arch,
'image-id': f'{image[0]["id"]}',
}
)
hostname = f'{host_name}.{provisioning.config_env["domain"]}'
assert hostname == host['name']
host_info = Host.info({'name': hostname})
# Check on RHV, if VM exists
assert rhev.rhv_api.does_vm_exist(hostname)
# Get the information of created VM
rhv_vm = rhev.rhv_api.get_vm(hostname)
# Assert of Satellite mac address for VM and Mac of VM created is same
assert host_info.get('network').get('mac') == rhv_vm.get_nics()[0].mac.address
# Done. Do not try to SSH, this image-based test should work even without
# being in the same network as RHEV. We checked the VM exists and
# that's enough.
finally:
# Now, let's just remove the VM.
Settings.set(
{'name': "destroy_vm_on_host_delete", 'value': "Yes"}
) # will be reset by fixture
Host.delete({'id': host['id']})
def foreman_discovery(target_sat):
"""Steps to Configure foreman discovery
1. Build PXE default template
2. Create Organization/Location
3. Update Global parameters to set default org and location for
discovered hosts.
4. Enable auto_provision flag to perform discovery via discovery
rules.
"""
# Build PXE default template to get default PXE file
Template.build_pxe_default()
# let's just modify the timeouts to speed things up
target_sat.execute(
"sed -ie 's/TIMEOUT [[:digit:]]\\+/TIMEOUT 1/g' /var/lib/tftpboot/pxelinux.cfg/default"
)
target_sat.execute(
"sed -ie '/APPEND initrd/s/$/ fdi.countdown=1/' /var/lib/tftpboot/pxelinux.cfg/default"
)
# Create Org and location
org = make_org()
loc = make_location()
# Get default settings values
default_discovery_loc = Settings.list({'search': 'name=discovery_location'})[0]
default_discovery_org = Settings.list({'search': 'name=discovery_organization'})[0]
default_discovery_auto = Settings.list({'search': 'name=discovery_auto'})[0]
# Update default org and location params to place discovered host
Settings.set({'name': 'discovery_location', 'value': loc['name']})
Settings.set({'name': 'discovery_organization', 'value': org['name']})
# Enable flag to auto provision discovered hosts via discovery rules
Settings.set({'name': 'discovery_auto', 'value': 'true'})
# Flag which shows whether environment is fully configured for
# discovered host provisioning.
configured_env = configure_env_for_provision(org=org, loc=loc)
yield {
'default_discovery_auto': default_discovery_auto,
'default_discovery_loc': default_discovery_loc,
'default_discovery_org': default_discovery_org,
'configured_env': configured_env,
}
# Restore default global setting's values
Settings.set({'name': 'discovery_location', 'value': default_discovery_loc['value']})
Settings.set({'name': 'discovery_organization', 'value': default_discovery_org['value']})
Settings.set({'name': 'discovery_auto', 'value': default_discovery_auto['value']})
def _setup_capsule(self):
"""Prepare the virtual machine to host a capsule node"""
# setup the name resolution
self._capsule_setup_name_resolution()
logger.info('adding repofiles required for capsule installation')
self.create_custom_repos(
capsule=settings.capsule_repo,
rhscl=settings.rhscl_repo,
ansible=settings.ansible_repo,
maint=settings.satmaintenance_repo,
)
self.configure_rhel_repo(settings.__dict__[self.distro + '_repo'])
self.run('yum repolist')
self.run('yum -y update')
self.run('yum -y install satellite-capsule', timeout=1200)
result = self.run('rpm -q satellite-capsule')
if result.return_code != 0:
raise CapsuleVirtualMachineError(
'Failed to install satellite-capsule package\n{}'.format(
result.stderr))
# update http proxy except list
result = Settings.list({'search': 'http_proxy_except_list'})[0]
if result["value"] == "[]":
except_list = '[{0}]'.format(self.hostname)
else:
except_list = result["value"][:-1] + ', {0}]'.format(self.hostname)
Settings.set({'name': 'http_proxy_except_list', 'value': except_list})
# generate certificate
cert_file_path = '/root/{0}-certs.tar'.format(self.hostname)
certs_gen = ssh.command('capsule-certs-generate '
'--foreman-proxy-fqdn {0} '
'--certs-tar {1}'.format(
self.hostname, cert_file_path))
if certs_gen.return_code != 0:
raise CapsuleVirtualMachineError(
'Unable to generate certificate\n{}'.format(certs_gen.stderr))
# copy the certificate to capsule vm
_, temporary_local_cert_file_path = mkstemp(suffix='-certs.tar')
logger.info('downloading the certs file: {0}'.format(cert_file_path))
download_file(
remote_file=cert_file_path,
local_file=temporary_local_cert_file_path,
hostname=settings.server.hostname,
)
logger.info('uploading the certs file: {0}'.format(cert_file_path))
upload_file(
key_filename=settings.server.ssh_key,
local_file=temporary_local_cert_file_path,
remote_file=cert_file_path,
hostname=self.ip_addr,
)
# delete the temporary file
os.remove(temporary_local_cert_file_path)
installer_cmd = extract_capsule_satellite_installer_command(
certs_gen.stdout)
installer_cmd += " --verbose"
result = self.run(installer_cmd, timeout=1800)
if result.return_code != 0:
# before exit download the capsule log file
_, log_path = mkstemp(prefix='capsule_external-', suffix='.log')
download_file('/var/log/foreman-installer/capsule.log', log_path,
self.ip_addr)
raise CapsuleVirtualMachineError(
result.return_code, result.stderr,
'foreman installer failed at capsule host')
# manually start pulp_celerybeat service if BZ1446930 is open
result = self.run('systemctl status pulp_celerybeat.service')
if 'inactive (dead)' in '\n'.join(result.stdout):
if is_open('BZ:1446930'):
result = self.run('systemctl start pulp_celerybeat.service')
if result.return_code != 0:
raise CapsuleVirtualMachineError(
'Failed to start pulp_celerybeat service\n{}'.format(
result.stderr))
else:
raise CapsuleVirtualMachineError(
'pulp_celerybeat service not running')
def tearDown(self):
"""Will reset the changed value of settings"""
yield
Settings.set({'name': "outofsync_interval", 'value': "30"})
def tearDown(self):
"""Will reset the changed value of settings"""
Settings.set({
'name': "outofsync_interval",
'value': "30"
})
