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_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" })