formelement.py

Go to the documentation of this file.

# Copyright 2008-2011 Nokia Networks
# Copyright 2011-2016 Ryan Tomac, Ed Manlove and contributors
# Copyright 2016-     Robot Framework Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
 
import os
 
from SeleniumLibrary.base import LibraryComponent, keyword
from SeleniumLibrary.errors import ElementNotFound
from SeleniumLibrary.utils import is_noney, is_truthy
 
 
class FormElementKeywords(LibraryComponent):
 
    @keyword
    
    def submit_form(self, locator=None):
        self.infoinfo("Submitting form '%s'." % locator)
        if is_noney(locator):
            locator = 'tag:form'
        element = self.find_elementfind_element(locator, tag='form')
        element.submit()
 
    @keyword
    
    def checkbox_should_be_selected(self, locator):
        self.infoinfo("Verifying checkbox '%s' is selected." % locator)
        element = self._get_checkbox_get_checkbox(locator)
        if not element.is_selected():
            raise AssertionError("Checkbox '%s' should have been selected "
                                 "but was not." % locator)
 
    @keyword
    
    def checkbox_should_not_be_selected(self, locator):
        self.infoinfo("Verifying checkbox '%s' is not selected." % locator)
        element = self._get_checkbox_get_checkbox(locator)
        if element.is_selected():
            raise AssertionError("Checkbox '%s' should not have been "
                                 "selected." % locator)
 
    @keyword
    
    def page_should_contain_checkbox(self, locator, message=None, loglevel='TRACE'):
        self.assert_page_containsassert_page_contains(locator, 'checkbox', message, loglevel)
 
    @keyword
    
    def page_should_not_contain_checkbox(self, locator, message=None, loglevel='TRACE'):
        self.assert_page_not_containsassert_page_not_contains(locator, 'checkbox', message, loglevel)
 
    @keyword
    
    def select_checkbox(self, locator):
        self.infoinfo("Selecting checkbox '%s'." % locator)
        element = self._get_checkbox_get_checkbox(locator)
        if not element.is_selected():
            element.click()
 
    @keyword
    
    def unselect_checkbox(self, locator):
        self.infoinfo("Unselecting checkbox '%s'." % locator)
        element = self._get_checkbox_get_checkbox(locator)
        if element.is_selected():
            element.click()
 
    @keyword
    
    def page_should_contain_radio_button(self, locator, message=None, loglevel='TRACE'):
        self.assert_page_containsassert_page_contains(locator, 'radio button', message, loglevel)
 
    @keyword
    
    def page_should_not_contain_radio_button(self, locator, message=None, loglevel='TRACE'):
        self.assert_page_not_containsassert_page_not_contains(locator, 'radio button', message,
                                      loglevel)
 
    @keyword
    
    def radio_button_should_be_set_to(self, group_name, value):
        self.infoinfo("Verifying radio button '%s' has selection '%s'."
                  % (group_name, value))
        elements = self._get_radio_buttons_get_radio_buttons(group_name)
        actual_value = self._get_value_from_radio_buttons_get_value_from_radio_buttons(elements)
        if actual_value is None or actual_value != value:
            raise AssertionError("Selection of radio button '%s' should have "
                                 "been '%s' but was '%s'."
                                 % (group_name, value, actual_value))
 
    @keyword
    
    def radio_button_should_not_be_selected(self, group_name):
        self.infoinfo("Verifying radio button '%s' has no selection." % group_name)
        elements = self._get_radio_buttons_get_radio_buttons(group_name)
        actual_value = self._get_value_from_radio_buttons_get_value_from_radio_buttons(elements)
        if actual_value is not None:
            raise AssertionError("Radio button group '%s' should not have "
                                 "had selection, but '%s' was selected."
                                 % (group_name, actual_value))
 
    @keyword
    
    def select_radio_button(self, group_name, value):
        self.infoinfo("Selecting '%s' from radio button '%s'."
                  % (value, group_name))
        element = self._get_radio_button_with_value_get_radio_button_with_value(group_name, value)
        if not element.is_selected():
            element.click()
 
    @keyword
    
    def choose_file(self, locator, file_path):
        if not os.path.isfile(file_path):
            raise ValueError("File '%s' does not exist on the local file "
                             "system." % file_path)
        self.find_elementfind_element(locator).send_keys(file_path)
 
    @keyword
    
    def input_password(self, locator, password, clear=True):
        self.infoinfo("Typing password into text field '%s'." % locator)
        self._input_text_into_text_field_input_text_into_text_field(locator, password, clear)
 
    @keyword
    
    def input_text(self, locator, text, clear=True):
        self.infoinfo("Typing text '%s' into text field '%s'." % (text, locator))
        self._input_text_into_text_field_input_text_into_text_field(locator, text, clear)
 
    @keyword
    
    def page_should_contain_textfield(self, locator, message=None, loglevel='TRACE'):
        self.assert_page_containsassert_page_contains(locator, 'text field', message, loglevel)
 
    @keyword
    
    def page_should_not_contain_textfield(self, locator, message=None, loglevel='TRACE'):
        self.assert_page_not_containsassert_page_not_contains(locator, 'text field', message, loglevel)
 
    @keyword
    
    def textfield_should_contain(self, locator, expected, message=None):
        actual = self._get_value_get_value(locator, 'text field')
        if expected not in actual:
            if is_noney(message):
                message = "Text field '%s' should have contained text '%s' "\
                          "but it contained '%s'." % (locator, expected, actual)
            raise AssertionError(message)
        self.infoinfo("Text field '%s' contains text '%s'." % (locator, expected))
 
    @keyword
    
    def textfield_value_should_be(self, locator, expected, message=None):
        actual = self._get_value_get_value(locator, 'text field')
        if actual != expected:
            if is_noney(message):
                message = "Value of text field '%s' should have been '%s' "\
                          "but was '%s'." % (locator, expected, actual)
            raise AssertionError(message)
        self.infoinfo("Content of text field '%s' is '%s'." % (locator, expected))
 
    @keyword
    
    def textarea_should_contain(self, locator, expected, message=None):
        actual = self._get_value_get_value(locator, 'text area')
        if expected not in actual:
            if is_noney(message):
                message = "Text area '%s' should have contained text '%s' " \
                          "but it had '%s'." % (locator, expected, actual)
            raise AssertionError(message)
        self.infoinfo("Text area '%s' contains text '%s'." % (locator, expected))
 
    @keyword
    
    def textarea_value_should_be(self, locator, expected, message=None):
        actual = self._get_value_get_value(locator, 'text area')
        if expected != actual:
            if is_noney(message):
                message = "Text area '%s' should have had text '%s' " \
                          "but it had '%s'." % (locator, expected, actual)
            raise AssertionError(message)
        self.infoinfo("Content of text area '%s' is '%s'." % (locator, expected))
 
    @keyword
    
    def page_should_contain_button(self, locator, message=None, loglevel='TRACE'):
        try:
            self.assert_page_containsassert_page_contains(locator, 'input', message, loglevel)
        except AssertionError:
            self.assert_page_containsassert_page_contains(locator, 'button', message, loglevel)
 
    @keyword
    
    def page_should_not_contain_button(self, locator, message=None, loglevel='TRACE'):
        self.assert_page_not_containsassert_page_not_contains(locator, 'button', message, loglevel)
        self.assert_page_not_containsassert_page_not_contains(locator, 'input', message, loglevel)
 
    def _get_value(self, locator, tag):
        return self.find_elementfind_element(locator, tag).get_attribute('value')
 
    def _get_checkbox(self, locator):
        return self.find_elementfind_element(locator, tag='checkbox')
 
    def _get_radio_buttons(self, group_name):
        xpath = "xpath://input[@type='radio' and @name='%s']" % group_name
        self.debugdebug('Radio group locator: ' + xpath)
        elements = self.find_elementsfind_elements(xpath)
        if not elements:
            raise ElementNotFound("No radio button with name '%s' found."
                                  % group_name)
        return elements
 
    def _get_radio_button_with_value(self, group_name, value):
        xpath = "xpath://input[@type='radio' and @name='%s' and " \
                "(@value='%s' or @id='%s')]" % (group_name, value, value)
        self.debugdebug('Radio group locator: ' + xpath)
        try:
            return self.find_elementfind_element(xpath)
        except ElementNotFound:
            raise ElementNotFound("No radio button with name '%s' and "
                                  "value '%s' found." % (group_name, value))
 
    def _get_value_from_radio_buttons(self, elements):
        for element in elements:
            if element.is_selected():
                return element.get_attribute('value')
        return None
 
    def _input_text_into_text_field(self, locator, text, clear):
        element = self.find_elementfind_element(locator)
        if is_truthy(clear):
            element.clear()
        element.send_keys(text)