Python TableElementFinder.find_by_header方法代码示例

# 需要导入模块: from Selenium2Library.locators import TableElementFinder [as 别名]
# 或者: from Selenium2Library.locators.TableElementFinder import find_by_header [as 别名]
    def test_find_by_header_with_css_locator(self):
        finder = TableElementFinder()
        browser = mock()
        when(browser).find_elements_by_css_selector("table#test1 th").thenReturn([])

        finder.find_by_header(browser, "css=table#test1", 'hi')

        verify(browser).find_elements_by_css_selector("table#test1 th")

# 需要导入模块: from Selenium2Library.locators import TableElementFinder [as 别名]
# 或者: from Selenium2Library.locators.TableElementFinder import find_by_header [as 别名]
    def test_find_by_header_with_xpath_locator(self):
        finder = TableElementFinder()
        browser = mock()
        when(browser).find_elements_by_xpath("//table[@id='test1']//th").thenReturn([])

        finder.find_by_header(browser, "xpath=//table[@id='test1']", 'hi')

        verify(browser).find_elements_by_xpath("//table[@id='test1']//th")

# 需要导入模块: from Selenium2Library.locators import TableElementFinder [as 别名]
# 或者: from Selenium2Library.locators.TableElementFinder import find_by_header [as 别名]
class _TableElementKeywords(KeywordGroup):

    def __init__(self):
        self._table_element_finder = TableElementFinder()

    # Public

    def get_table_cell(self, table_locator, row, column, loglevel='INFO'):
        """Returns the content from a table cell.

        Row and column number start from 1. Header and footer rows are
        included in the count. A negative row or column number can be used
        to get rows counting from the end (end: -1). Cell content from header 
        or footer rows can be obtained with this keyword. To understand how 
        tables are identified, please take a look at the `introduction`.
        
        See `Page Should Contain` for explanation about `loglevel` argument.
        """
        row = int(row)
        row_index = row
        if row > 0: row_index = row - 1
        column = int(column)
        column_index = column
        if column > 0: column_index = column - 1
        table = self._table_element_finder.find(self._current_browser(), table_locator)
        if table is not None:
            rows = table.find_elements_by_xpath("./thead/tr")
            if row_index >= len(rows) or row_index < 0: 
                rows.extend(table.find_elements_by_xpath("./tbody/tr"))
            if row_index >= len(rows) or row_index < 0: 
                rows.extend(table.find_elements_by_xpath("./tfoot/tr"))
            if row_index < len(rows):
                columns = rows[row_index].find_elements_by_tag_name('th')
                if column_index >= len(columns) or column_index < 0: 
                    columns.extend(rows[row_index].find_elements_by_tag_name('td'))
                if column_index < len(columns):
                    return columns[column_index].text
        self.log_source(loglevel)
        raise AssertionError("Cell in table %s in row #%s and column #%s could not be found."
            % (table_locator, str(row), str(column)))

    def get_table_rows(self, table_locator, loglevel='INFO'):
        """add by qitao016. 20131115
        get_table_rows: return the rows of the table.
        """
        table = self._table_element_finder.find(self._current_browser(), table_locator)
        if table is not None:
            rows = table.find_elements_by_xpath("./thead/tr")
            rows.extend(table.find_elements_by_xpath("./tbody/tr"))
            rows.extend(table.find_elements_by_xpath("./tfoot/tr"))
            return len(rows)
        self.log_source(loglevel)
        raise AssertionError("Table %s could not be found." % table_locator)

    def get_table_cols_at_row(self, table_locator, row, loglevel='INFO'):
        """add by qitao016. 20131115
        get_table_cols_at_row: return the cols of the table in one row.
        """
        row = int(row)
        row_index = row - 1
        table = self._table_element_finder.find(self._current_browser(), table_locator)
        if table is not None:
            rows = table.find_elements_by_xpath("./thead/tr")
            if row_index >= len(rows): rows.extend(table.find_elements_by_xpath("./tbody/tr"))
            if row_index >= len(rows): rows.extend(table.find_elements_by_xpath("./tfoot/tr"))
            if row_index < len(rows):
                columns = rows[row_index].find_elements_by_tag_name('th')
                columns.extend(rows[row_index].find_elements_by_tag_name('td'))
                return len(columns)
        raise AssertionError("Cell in Table %s in row #%s could not be found." % (table_locator, str(row)))		
			
    def get_index_in_table_column(self, table_locator, col, expected, loglevel='INFO'):
        """add by Adam Wu CSS version. get content's index in a specific column contains `content`.

        Row and column number start from 1. Header and footer rows are
        included in the count. However, the header and footer content
        will not be matched against 'expected'.

        See `Page Should Contain Element` for explanation about `loglevel` argument.
        """
        has_head=0
        element = self._table_element_finder.find_by_header(self._current_browser(), table_locator, None)
        if element is not None:
            has_head = 1
        index = self._table_element_finder.find_in_col(self._current_browser(), table_locator, col, expected)
        if index <= 0:
            self.log_source(loglevel)
            raise AssertionError("Column #%s in table identified by '%s' "
                   "should have contained text '%s'."
                   % (col, table_locator, expected))
        return index+has_head
	
    def get_index_in_table_row(self, table_locator, row, expected, loglevel='INFO'):
        """added by Adam Wu. Get content's index in a specific table row contains `content`.

        Row and column number start from 1. Header and footer rows are
        included in the count. This means that also cell content from
        header or footer rows can be obtained with this keyword. To
        understand how tables are identified, please take a look at
        the `introduction`.
#.........这里部分代码省略.........

# 需要导入模块: from Selenium2Library.locators import TableElementFinder [as 别名]
# 或者: from Selenium2Library.locators.TableElementFinder import find_by_header [as 别名]

#.........这里部分代码省略.........
        self._info("Cell contains %s." % (content))
        if expected not in content:
            self.log_source(loglevel)
            raise AssertionError(message)

    def table_column_should_contain(self, table_locator, col, expected, loglevel='INFO'):
        """Verifies that a specific column contains `expected`.

        The first leftmost column is column number 1. A negative column
        number can be used to get column counting from the end of the row (end: -1).
        If the table contains cells that span multiple columns, those merged cells
        count as a single column. For example both tests below work,
        if in one row columns A and B are merged with colspan="2", and
        the logical third column contains "C".

        Example:
        | Table Column Should Contain | tableId | 3 | C |
        | Table Column Should Contain | tableId | 2 | C |

        To understand how tables are identified, please take a look at
        the `introduction`.

        See `Page Should Contain Element` for explanation about
        `loglevel` argument.
        """
        element = self._table_element_finder.find_by_col(self._current_browser(), table_locator, col, expected)
        if element is None:
            self.log_source(loglevel)
            raise AssertionError("Column #%s in table identified by '%s' "
                   "should have contained text '%s'."
                   % (col, table_locator, expected))

    def table_footer_should_contain(self, table_locator, expected, loglevel='INFO'):
        """Verifies that the table footer contains `expected`.

        With table footer can be described as any <td>-element that is
        child of a <tfoot>-element.  To understand how tables are
        identified, please take a look at the `introduction`.

        See `Page Should Contain Element` for explanation about
        `loglevel` argument.
        """
        element = self._table_element_finder.find_by_footer(self._current_browser(), table_locator, expected)
        if element is None:
            self.log_source(loglevel)
            raise AssertionError("Footer in table identified by '%s' should have contained "
                   "text '%s'." % (table_locator, expected))

    def table_header_should_contain(self, table_locator, expected, loglevel='INFO'):
        """Verifies that the table header, i.e. any <th>...</th> element, contains `expected`.

        To understand how tables are identified, please take a look at
        the `introduction`.

        See `Page Should Contain Element` for explanation about
        `loglevel` argument.
        """
        element = self._table_element_finder.find_by_header(self._current_browser(), table_locator, expected)
        if element is None:
            self.log_source(loglevel)
            raise AssertionError("Header in table identified by '%s' should have contained "
               "text '%s'." % (table_locator, expected))

    def table_row_should_contain(self, table_locator, row, expected, loglevel='INFO'):
        """Verifies that a specific table row contains `expected`.

        The uppermost row is row number 1. A negative column
        number can be used to get column counting from the end of the row
        (end: -1). For tables that are structured with thead, tbody and tfoot,
        only the tbody section is searched. Please use `Table Header Should Contain`
        or `Table Footer Should Contain` for tests against the header or
        footer content.

        If the table contains cells that span multiple rows, a match
        only occurs for the uppermost row of those merged cells. To
        understand how tables are identified, please take a look at
        the `introduction`.

        See `Page Should Contain Element` for explanation about `loglevel` argument.
        """
        element = self._table_element_finder.find_by_row(self._current_browser(), table_locator, row, expected)
        if element is None:
            self.log_source(loglevel)
            raise AssertionError("Row #%s in table identified by '%s' should have contained "
                   "text '%s'." % (row, table_locator, expected))

    def table_should_contain(self, table_locator, expected, loglevel='INFO'):
        """Verifies that `expected` can be found somewhere in the table.

        To understand how tables are identified, please take a look at
        the `introduction`.

        See `Page Should Contain Element` for explanation about
        `loglevel` argument.
        """
        element = self._table_element_finder.find_by_content(self._current_browser(), table_locator, expected)
        if element is None:
            self.log_source(loglevel)
            raise AssertionError("Table identified by '%s' should have contained text '%s'." \
                % (table_locator, expected))