Beispiel #1
0
    def test_positive_update_manage_puppetca_param(self):
        """Updates parameter "manage_puppetca" under Provisioning tab

        :id: 2f652441-6beb-40c0-9fb3-f0b835d06ca7

        :expectedresults: Parameter is updated successfully

        :CaseImportance: Critical
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'manage_puppetca'
        with Session(self) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #2
0
    def test_positive_update_trusted_puppetmaster_hosts_param(self):
        """Updates parameter "trusted_puppetmaster_hosts" under Auth tab

        @id: 18596dbc-7e2a-426c-bd1a-338a31ba6e97

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'trusted_puppetmaster_hosts'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_trusted_puppetmaster_hosts():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #3
0
    def test_positive_update_query_local_nameservers_param(self):
        """Updates parameter "query_local_nameservers" under
        Provisioning tab

        @id: 643960f4-121c-44f3-a5e8-00b9cf66ff99

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'query_local_nameservers'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #4
0
    def test_positive_update_idle_timeout_param(self):
        """Updates parameter "idle_timeout" under Auth tab

        @id: fd5b2fe0-7124-444b-9f00-fca2b38c52f4

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'idle_timeout'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_maxtrend_timeout_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #5
0
    def test_positive_update_auth_source_user_autocreate_param(self):
        """Updates parameter
        "authorize_login_delegation_auth_source_user_autocreate" under Auth tab

        @id: 82137c0c-1cf5-445d-87fe-1ff80a12df3c

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = ('authorize_login_delegation_auth_source_user'
                           '_autocreate')
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_login_delegation_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #6
0
    def test_positive_update_authorize_login_delegation_api_param(self):
        """Updates parameter "authorize_login_delegation_api" under Auth tab

        @id: 1dc39d96-a0e3-4d2e-aeb8-14aedab2ebe3

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'authorize_login_delegation_api'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #7
0
    def test_positive_update_use_gravatar_param(self):
        """Updates parameter "use_gravatar" under General tab

        @id: 6ea676c1-acb9-495f-9ee7-0a2c14f34ea1

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'use_gravatar'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #8
0
    def test_positive_update_email_reply_address_param(self):
        """Updates parameter "email_reply_address" under General tab

        @id: 274eaa6d-a6ba-4dbe-a843-c3717fbd70ae

        @Assert: Parameter is updated successfully

        @BZ: 1125181
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'email_reply_address'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #9
0
    def test_positive_update_fix_db_cache_param(self):
        """Updates parameter "fix_db_cache" under General tab

        @id: b7f8df0e-9ac8-4075-8955-c895267e424c

        @Assert: Parameter is updated successfully

        @BZ: 1156195
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'fix_db_cache'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #10
0
    def test_positive_update_administrator_param(self):
        """Updates parameter "administrator" under General tab

        @id: ecab6d51-ad29-4904-bc04-e62673ab1028

        @Assert: Parameter is updated successfully

        @BZ: 1125181
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'administrator'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #11
0
    def test_positive_update_authorize_login_delegation_api_param(self):
        """Updates parameter "authorize_login_delegation_api" under Auth tab

        @id: 1dc39d96-a0e3-4d2e-aeb8-14aedab2ebe3

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'authorize_login_delegation_api'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #12
0
    def test_positive_update_authorize_login_delegation_param(self):
        """Updates parameter "authorize_login_delegation" under Auth tab

        @id: 0b752f6a-5987-483a-9cef-2d02fa42fe73

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'authorize_login_delegation'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #13
0
    def test_positive_update_safemode_render_param(self):
        """Updates parameter "safemode_render" under Provisioning tab

        :id: 4762a89a-2ebe-4834-b44f-f74888e609bb

        :expectedresults: Parameter is updated successfully

        :CaseImportance: Critical
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'safemode_render'
        with Session(self) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #14
0
    def test_positive_update_query_local_nameservers_param(self):
        """Updates parameter "query_local_nameservers" under
        Provisioning tab

        :id: 643960f4-121c-44f3-a5e8-00b9cf66ff99

        :expectedresults: Parameter is updated successfully

        :CaseImportance: Critical
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'query_local_nameservers'
        with Session(self) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #15
0
    def test_negative_update_trusted_puppetmaster_hosts_param(self):
        """Updates parameter "trusted_puppetmaster_hosts" under Auth tab

        @Feature: Settings - Negative update Parameters

        @Assert: Parameter is not updated

        @BZ: 1125156
        """
        tab_locator = tab_locators['settings.tab_auth']
        param_name = 'trusted_puppetmaster_hosts'
        with Session(self.browser) as session:
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=tab_locator,
                        param_name=param_name,
                        value_type='input',
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    saved_element = self.settings.get_saved_value(
                        tab_locator, param_name)
                    self.assertNotEqual(param_value, saved_element)
Beispiel #16
0
    def test_positive_update_use_gravatar_param(self):
        """Updates parameter "use_gravatar" under General tab

        @id: 6ea676c1-acb9-495f-9ee7-0a2c14f34ea1

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'use_gravatar'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #17
0
    def test_positive_update_authorize_login_delegation_param(self):
        """Updates parameter "authorize_login_delegation" under Auth tab

        @id: 0b752f6a-5987-483a-9cef-2d02fa42fe73

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'authorize_login_delegation'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #18
0
    def test_positive_update_max_trend_param(self):
        """Updates parameter "max_trend" under General tab

        @id: 6e08bb3b-de48-45b4-b982-7180dbb65ed2

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'max_trend'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_maxtrend_timeout_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #19
0
    def test_positive_update_email_reply_address_param(self):
        """Updates parameter "email_reply_address" under General tab

        @id: 274eaa6d-a6ba-4dbe-a843-c3717fbd70ae

        @Assert: Parameter is updated successfully

        @BZ: 1125181
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'email_reply_address'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #20
0
    def test_positive_update_idle_timeout_param(self):
        """Updates parameter "idle_timeout" under Auth tab

        @id: fd5b2fe0-7124-444b-9f00-fca2b38c52f4

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'idle_timeout'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_maxtrend_timeout_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #21
0
    def test_positive_update_max_trend_param(self):
        """Updates parameter "max_trend" under General tab

        @id: 6e08bb3b-de48-45b4-b982-7180dbb65ed2

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'max_trend'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_maxtrend_timeout_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #22
0
    def test_positive_update_foreman_url_param(self):
        """Updates parameter "foreman_url" under General tab

        @id: e09e95e9-510a-48b6-a59f-5adc0a383ddc

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'foreman_url'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_urls():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #23
0
    def test_negative_update_foreman_url_param(self):
        """Updates parameter "foreman_url" under General tab

        @id: ee450e0a-d02e-40c4-a67e-5508a29dc9c8

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'foreman_url'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_foreman_urls():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    session.nav.click(common_locators['notif.close'])
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #24
0
    def test_positive_update_dynflow_enable_console_param(self):
        """Updates parameter "dynflow_enable_console" under ForemanTasks
        tab

        @id: 11a710f1-d5fc-48c7-9f31-a92dbbaebc40

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_foremantasks']
        self.param_name = 'dynflow_enable_console'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #25
0
    def test_positive_update_require_ssl_smart_proxies_param(self):
        """Updates parameter "require_ssl_smart_proxies" under Auth tab

        @id: 79d5bb5f-6bec-4c1c-b68e-6727aeb04614

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'require_ssl_smart_proxies'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #26
0
    def test_positive_update_login_delegation_logout_url_param(self):
        """Updates parameter "login_delegation_logout_url" under Auth
        tab

        @id: 67b32c5f-7e8e-4ba7-ab29-9af2ac3660a9

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'login_delegation_logout_url'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_urls():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #27
0
    def test_positive_update_ignore_puppet_facts_for_provisioning_param(self):
        """Updates parameter "ignore_puppet_facts_for_provisioning" under
        Provisioning tab

        @id: 71cb4779-7982-43b6-ab65-7198ec193941

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'ignore_puppet_facts_for_provisioning'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #28
0
    def test_positive_update_require_ssl_smart_proxies_param(self):
        """Updates parameter "require_ssl_smart_proxies" under Auth tab

        @id: 79d5bb5f-6bec-4c1c-b68e-6727aeb04614

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'require_ssl_smart_proxies'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #29
0
    def test_negative_update_token_duration_param(self):
        """Updates parameter "token_duration" under Provisioning tab
        with invalid values

        @id: a1d18ba3-a14f-47ab-82fb-1249abc7b076

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'token_duration'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_token_duration():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    session.nav.click(common_locators['notif.close'])
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #30
0
    def test_positive_update_trusted_puppetmaster_hosts_param(self):
        """Updates parameter "trusted_puppetmaster_hosts" under Auth tab

        @id: 18596dbc-7e2a-426c-bd1a-338a31ba6e97

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'trusted_puppetmaster_hosts'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_trusted_puppetmaster_hosts():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #31
0
    def test_positive_update_restrict_registered_puppetmasters_param(self):
        """Updates parameter "restrict_registered_puppetmasters" under
        Auth tab

        @Feature: Settings - Update Parameters

        @Assert: Parameter is updated successfully
        """
        tab_locator = tab_locators['settings.tab_auth']
        param_name = 'restrict_registered_puppetmasters'
        value_type = 'dropdown'
        with Session(self.browser) as session:
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    session.nav.go_to_settings()
                    default_value = self.settings.get_saved_value(
                        tab_locator, param_name)
                    edit_param(
                        session,
                        tab_locator=tab_locator,
                        param_name=param_name,
                        value_type=value_type,
                        param_value=param_value,
                    )
                    saved_element = self.settings.get_saved_value(
                        tab_locator, param_name)
                    self.assertEqual(param_value, saved_element)
                    edit_param(
                        session,
                        tab_locator=tab_locator,
                        param_name=param_name,
                        value_type=value_type,
                        param_value=default_value,
                    )
Beispiel #32
0
    def test_positive_update_ignore_puppet_facts_for_provisioning_param(self):
        """Updates parameter "ignore_puppet_facts_for_provisioning" under
        Provisioning tab

        @id: 71cb4779-7982-43b6-ab65-7198ec193941

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'ignore_puppet_facts_for_provisioning'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #33
0
    def test_negative_update_token_duration_param(self):
        """Updates parameter "token_duration" under Provisioning tab
        with invalid values

        @Feature: Settings - Negative Update Parameters

        @Assert: Parameter is not updated

        @BZ: 1125156
        """
        tab_locator = tab_locators['settings.tab_provisioning']
        param_name = 'token_duration'
        with Session(self.browser) as session:
            for param_value in invalid_token_duration():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=tab_locator,
                        param_name=param_name,
                        value_type='input',
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    saved_element = self.settings.get_saved_value(
                        tab_locator, param_name)
                    self.assertNotEqual(param_value, saved_element)
Beispiel #34
0
    def test_positive_update_manage_puppetca_param(self):
        """Updates parameter "manage_puppetca" under Provisioning tab

        @id: 2f652441-6beb-40c0-9fb3-f0b835d06ca7

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'manage_puppetca'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #35
0
    def test_positive_update_administrator_param(self):
        """Updates parameter "administrator" under General tab

        @id: ecab6d51-ad29-4904-bc04-e62673ab1028

        @Assert: Parameter is updated successfully

        @BZ: 1125181
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'administrator'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #36
0
    def test_positive_update_query_local_nameservers_param(self):
        """Updates parameter "query_local_nameservers" under
        Provisioning tab

        @id: 643960f4-121c-44f3-a5e8-00b9cf66ff99

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'query_local_nameservers'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #37
0
    def test_negative_update_entries_per_page_param(self):
        """Updates parameter "entries_per_page" under General tab with
        invalid values

        @id: b6bb39e2-797e-43e4-9629-d319c62992a4

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'entries_per_page'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    session.nav.click(common_locators['notif.close'])
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #38
0
    def test_positive_update_safemode_render_param(self):
        """Updates parameter "safemode_render" under Provisioning tab

        @id: 4762a89a-2ebe-4834-b44f-f74888e609bb

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'safemode_render'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #39
0
    def test_positive_update_fix_db_cache_param(self):
        """Updates parameter "fix_db_cache" under General tab

        @id: b7f8df0e-9ac8-4075-8955-c895267e424c

        @Assert: Parameter is updated successfully

        @BZ: 1156195
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'fix_db_cache'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #40
0
    def test_negative_update_entries_per_page_param(self):
        """Updates parameter "entries_per_page" under General tab with
        invalid values

        @id: b6bb39e2-797e-43e4-9629-d319c62992a4

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'entries_per_page'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['haserror']))
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #41
0
    def test_negative_update_max_trend_param(self):
        """Updates parameter "max_trend" under General tab with invalid
        values

        @id: bcc2848d-734a-4b13-80fa-9fd34545cbe7

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'max_trend'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    session.nav.click(common_locators['notif.close'])
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #42
0
    def test_negative_update_max_trend_param(self):
        """Updates parameter "max_trend" under General tab with invalid
        values

        @id: bcc2848d-734a-4b13-80fa-9fd34545cbe7

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'max_trend'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['haserror']))
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #43
0
    def test_negative_update_idle_timeout_param(self):
        """Updates parameter "idle_timeout" under General tab with
        invalid values

        @id: 0c46ec21-7402-4241-8b22-5f8afa1f5316

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'idle_timeout'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    session.nav.click(common_locators['notif.close'])
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #44
0
    def test_negative_update_idle_timeout_param(self):
        """Updates parameter "idle_timeout" under General tab with
        invalid values

        @id: 0c46ec21-7402-4241-8b22-5f8afa1f5316

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'idle_timeout'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['haserror']))
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #45
0
    def test_positive_update_foreman_url_param(self):
        """Updates parameter "foreman_url" under General tab

        @id: e09e95e9-510a-48b6-a59f-5adc0a383ddc

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'foreman_url'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_urls():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #46
0
    def test_negative_update_foreman_url_param(self):
        """Updates parameter "foreman_url" under General tab

        @id: ee450e0a-d02e-40c4-a67e-5508a29dc9c8

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_general']
        self.param_name = 'foreman_url'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_foreman_urls():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['haserror']))
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #47
0
    def test_positive_update_dynflow_enable_console_param(self):
        """Updates parameter "dynflow_enable_console" under ForemanTasks
        tab

        @id: 11a710f1-d5fc-48c7-9f31-a92dbbaebc40

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_foremantasks']
        self.param_name = 'dynflow_enable_console'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #48
0
    def test_positive_update_auth_source_user_autocreate_param(self):
        """Updates parameter
        "authorize_login_delegation_auth_source_user_autocreate" under Auth tab

        @id: 82137c0c-1cf5-445d-87fe-1ff80a12df3c

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = ('authorize_login_delegation_auth_source_user'
                           '_autocreate')
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_login_delegation_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #49
0
    def test_positive_update_login_delegation_logout_url_param(self):
        """Updates parameter "login_delegation_logout_url" under Auth
        tab

        @id: 67b32c5f-7e8e-4ba7-ab29-9af2ac3660a9

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'login_delegation_logout_url'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_urls():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #50
0
    def test_positive_update_restrict_registered_smart_proxies_param(self):
        """Updates parameter "restrict_registered_smart_proxies" under
        Auth tab

        @id: 7dbcf471-3cee-4718-a316-18da6c4c1ef0

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'restrict_registered_smart_proxies'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    self.original_value = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #51
0
    def test_positive_update_restrict_registered_smart_proxies_param(self):
        """Updates parameter "restrict_registered_smart_proxies" under
        Auth tab

        @id: 7dbcf471-3cee-4718-a316-18da6c4c1ef0

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'restrict_registered_smart_proxies'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    self.original_value = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #52
0
    def test_negative_update_trusted_puppetmaster_hosts_param(self):
        """Updates parameter "trusted_puppetmaster_hosts" under Auth tab

        @id: 23af2612-1291-41a1-8002-87263e39bdbe

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'trusted_puppetmaster_hosts'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['haserror']))
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #53
0
    def test_negative_update_trusted_puppetmaster_hosts_param(self):
        """Updates parameter "trusted_puppetmaster_hosts" under Auth tab

        @id: 23af2612-1291-41a1-8002-87263e39bdbe

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_auth']
        self.param_name = 'trusted_puppetmaster_hosts'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_settings_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    session.nav.click(common_locators['notif.close'])
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #54
0
    def test_negative_update_token_duration_param(self):
        """Updates parameter "token_duration" under Provisioning tab
        with invalid values

        @id: a1d18ba3-a14f-47ab-82fb-1249abc7b076

        @Assert: Parameter is not updated
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'token_duration'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in invalid_token_duration():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['haserror']))
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertNotEqual(param_value, self.saved_element)
Beispiel #55
0
    def test_positive_update_manage_puppetca_param(self):
        """Updates parameter "manage_puppetca" under Provisioning tab

        @id: 2f652441-6beb-40c0-9fb3-f0b835d06ca7

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'manage_puppetca'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #56
0
    def test_positive_update_token_duration_param(self):
        """Updates param "token_duration" under Provisioning tab

        @id: a200b578-4463-444b-bed1-82e540a77529

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'token_duration'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_token_duration():
                with self.subTest(param_value):
                    self.original_value = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #57
0
    def test_positive_update_safemode_render_param(self):
        """Updates parameter "safemode_render" under Provisioning tab

        @id: 4762a89a-2ebe-4834-b44f-f74888e609bb

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'safemode_render'
        self.value_type = 'dropdown'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #58
0
    def test_negative_update_foreman_url_param(self):
        """Updates parameter "foreman_url" under General tab

        @Feature: Settings - Negative update Parameters

        @Assert: Parameter is not updated

        @BZ: 1125156
        """
        tab_locator = tab_locators['settings.tab_general']
        param_name = 'foreman_url'
        with Session(self.browser) as session:
            for param_value in invalid_foreman_urls():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=tab_locator,
                        param_name=param_name,
                        value_type='input',
                        param_value=param_value,
                    )
                    self.assertIsNotNone(
                        session.nav.wait_until_element(
                            common_locators['notif.error'])
                    )
                    saved_element = self.settings.get_saved_value(
                        tab_locator, param_name)
                    self.assertNotEqual(param_value, saved_element)
Beispiel #59
0
    def test_positive_update_token_duration_param(self):
        """Updates param "token_duration" under Provisioning tab

        @id: a200b578-4463-444b-bed1-82e540a77529

        @Assert: Parameter is updated successfully
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'token_duration'
        self.value_type = 'input'
        with Session(self.browser) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_token_duration():
                with self.subTest(param_value):
                    self.original_value = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        value_type=self.value_type,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)
Beispiel #60
0
    def test_positive_update_ignore_puppet_facts_for_provisioning_param(self):
        """Updates parameter "ignore_puppet_facts_for_provisioning" under
        Provisioning tab

        :id: 71cb4779-7982-43b6-ab65-7198ec193941

        :expectedresults: Parameter is updated successfully

        :CaseImportance: Critical
        """
        self.tab_locator = tab_locators['settings.tab_provisioning']
        self.param_name = 'ignore_puppet_facts_for_provisioning'
        with Session(self) as session:
            self.original_value = self.settings.get_saved_value(
                self.tab_locator, self.param_name)
            for param_value in valid_boolean_values():
                with self.subTest(param_value):
                    edit_param(
                        session,
                        tab_locator=self.tab_locator,
                        param_name=self.param_name,
                        param_value=param_value,
                    )
                    self.saved_element = self.settings.get_saved_value(
                        self.tab_locator, self.param_name)
                    self.assertEqual(param_value, self.saved_element)