Python locators.TableElementFinder类代码示例

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

    def test_find_by_footer_with_css_locator(self):
        finder = TableElementFinder()
        browser = mock()
        when(browser).find_elements_by_css_selector("table#test1 tfoot td").thenReturn([])

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

        verify(browser).find_elements_by_css_selector("table#test1 tfoot td")

    def test_find_by_col_with_xpath_locator(self):
        finder = TableElementFinder()
        browser = mock()
        when(browser).find_elements_by_xpath("//table[@id='test1']//tr//*[self::td or self::th][2]").thenReturn([])

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

        verify(browser).find_elements_by_xpath("//table[@id='test1']//tr//*[self::td or self::th][2]")

    def test_find_with_implicit_css_locator(self):
        finder = TableElementFinder()
        browser = mock()
        when(browser).find_elements_by_css_selector("table#test1").thenReturn([])

        finder.find(browser, "test1")

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

    def test_find_by_row_with_css_locator(self):
        finder = TableElementFinder()
        browser = mock()
        when(browser).find_elements_by_css_selector("table#test1 tr:nth-child(2)").thenReturn([])

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

        verify(browser).find_elements_by_css_selector("table#test1 tr:nth-child(2)")

    def test_find_with_xpath_selector(self):
        finder = TableElementFinder()
        browser = mock()
        elements = self._make_mock_elements('table', 'table', 'table')
        when(browser).find_elements_by_xpath("//table[@id='test1']").thenReturn(elements)

        self.assertEqual(finder.find(browser, "xpath=//table[@id='test1']"), elements[0])

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

    def test_find_with_css_selector(self):
        finder = TableElementFinder()
        browser = mock()
        elements = self._make_mock_elements('table', 'table', 'table')
        when(browser).find_elements_by_css_selector("table#test1").thenReturn(elements)

        self.assertEqual(finder.find(browser, "css=table#test1"), elements[0])

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

    def test_find_with_null_content_constraint(self):
        finder = TableElementFinder()
        browser = mock()
        elements = self._make_mock_elements('td', 'td', 'td')
        elements[1].text = 'hi'
        when(browser).find_elements_by_css_selector("table#test1").thenReturn(elements)

        self.assertEqual(finder.find_by_content(browser, "test1", None), elements[0])

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

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. 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`.
        """
        row = int(row)
        row_index = row - 1
        column = int(column)
        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): 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')
                if column_index >= len(columns): 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 table_cell_should_contain(self, table_locator, row, column, expected, loglevel='INFO'):
        """Verifies that a certain cell in a table contains `expected`.

        Row and column number start from 1. This keyword passes if the
        specified cell contains the given content. If you want to test
        that the cell content matches exactly, or that it e.g. starts
        with some text, use `Get Table Cell` keyword in combination
        with built-in keywords such as `Should Be Equal` or `Should
        Start With`.

        To understand how tables are identified, please take a look at
        the `introduction`.
        """
        message = ("Cell in table '%s' in row #%s and column #%s "
                   "should have contained text '%s'."
                   % (table_locator, row, column, expected))
        try:
            content = self.get_table_cell(table_locator, row, column, loglevel='NONE')
        except AssertionError, err:
            self._info(err)
            self.log_source(loglevel)
            raise AssertionError(message)
        self._info("Cell contains %s." % (content))
        if expected not in content:
            self.log_source(loglevel)
            raise AssertionError(message)

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

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`.
#.........这里部分代码省略.........

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 table_cell_should_contain(self, table_locator, row, column, expected, loglevel='INFO'):
        """Verifies that a certain cell in a table contains `expected`.

        Row and column number start from 1. This keyword passes if the
        specified cell contains the given content. If you want to test
        that the cell content matches exactly, or that it e.g. starts
        with some text, use `Get Table Cell` keyword in combination
        with built-in keywords such as `Should Be Equal` or `Should
        Start With`.

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

        See `Page Should Contain` for explanation about `loglevel` argument.
        """
        message = ("Cell in table '%s' in row #%s and column #%s "
                   "should have contained text '%s'."
                   % (table_locator, row, column, expected))
        try:
            content = self.get_table_cell(table_locator, row, column, loglevel='NONE')
        except AssertionError as err:
            self._info(err)
            self.log_source(loglevel)
            raise AssertionError(message)
        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`.

#.........这里部分代码省略.........