test: refactor tests.test_table to use cxml

Steve Canny · Steve Canny · commit 51c79c6272ca · 2014-06-30T15:46:51.000-07:00
diff --git a/docx/oxml/table.py b/docx/oxml/table.py
@@ -77,12 +77,23 @@ class CT_TblPr(BaseOxmlElement):
     """
     tblStyle = ZeroOrOne('w:tblStyle')
 
-    def add_tblStyle(self, style_name):
+    @property
+    def style(self):
         """
-        Return a new <w:tblStyle> element having its style set to
-        *style_name*.
+        Return the value of the ``val`` attribute of the ``<w:tblStyle>``
+        child or |None| if not present.
         """
-        return self._add_tblStyle(val=style_name)
+        tblStyle = self.tblStyle
+        if tblStyle is None:
+            return None
+        return tblStyle.val
+
+    @style.setter
+    def style(self, value):
+        self._remove_tblStyle()
+        if value is None:
+            return
+        self._add_tblStyle(val=value)
 
 
 class CT_Tc(BaseOxmlElement):
diff --git a/docx/table.py b/docx/table.py
@@ -67,18 +67,12 @@ def style(self):
         'LightShading-Accent1'. Name is derived by removing spaces from the
         table style name displayed in the Word UI.
         """
-        tblStyle = self._tblPr.tblStyle
-        if tblStyle is None:
-            return None
-        return tblStyle.val
+        return self._tblPr.style
 
     @style.setter
-    def style(self, style_name):
-        tblStyle = self._tblPr.tblStyle
-        if tblStyle is None:
-            self._tblPr.add_tblStyle(style_name)
-        else:
-            tblStyle.val = style_name
+    def style(self, value):
+        print('style value is %s' % value)
+        self._tblPr.style = value
 
     @property
     def _tblPr(self):
diff --git a/tests/test_table.py b/tests/test_table.py
@@ -13,10 +13,9 @@
 )
 from docx.text import Paragraph
 
-from .oxml.unitdata.table import (
-    a_gridCol, a_tbl, a_tblGrid, a_tblPr, a_tblStyle, a_tc, a_tcPr, a_tr
-)
-from .oxml.unitdata.text import a_p, a_t, an_r
+from .oxml.unitdata.table import a_gridCol, a_tbl, a_tblGrid, a_tc, a_tr
+from .oxml.unitdata.text import a_p
+from .unitutil.cxml import element, xml
 
 
 class DescribeTable(object):
@@ -52,8 +51,8 @@ def it_can_add_a_column(self, add_column_fixture):
         assert isinstance(column, _Column)
         assert column._gridCol is table._tbl.tblGrid.gridCol_lst[1]
 
-    def it_knows_its_table_style(self, table_style_fixture):
-        table, style = table_style_fixture
+    def it_knows_its_table_style(self, table_style_get_fixture):
+        table, style = table_style_get_fixture
         assert table.style == style
 
     def it_can_apply_a_table_style_by_name(self, table_style_set_fixture):
@@ -77,94 +76,85 @@ def add_row_fixture(self):
         expected_xml = _tbl_bldr(rows=2, cols=2).xml()
         return table, expected_xml
 
+    @pytest.fixture(params=[
+        ('w:tbl/w:tblPr', None),
+        ('w:tbl/w:tblPr/w:tblStyle{w:val=foobar}', 'foobar'),
+    ])
+    def table_style_get_fixture(self, request):
+        tbl_cxml, expected_style = request.param
+        table = Table(element(tbl_cxml))
+        return table, expected_style
+
+    @pytest.fixture(params=[
+        ('w:tbl/w:tblPr', 'foobar',
+         'w:tbl/w:tblPr/w:tblStyle{w:val=foobar}'),
+        ('w:tbl/w:tblPr/w:tblStyle{w:val=foobar}', 'barfoo',
+         'w:tbl/w:tblPr/w:tblStyle{w:val=barfoo}'),
+        ('w:tbl/w:tblPr/w:tblStyle{w:val=foobar}', None,
+         'w:tbl/w:tblPr'),
+        ('w:tbl/w:tblPr', None,
+         'w:tbl/w:tblPr'),
+    ])
+    def table_style_set_fixture(self, request):
+        tbl_cxml, new_style, expected_cxml = request.param
+        table = Table(element(tbl_cxml))
+        expected_xml = xml(expected_cxml)
+        return table, new_style, expected_xml
+
+    # fixture components ---------------------------------------------
+
     @pytest.fixture
     def table(self):
         tbl = _tbl_bldr(rows=2, cols=2).element
         table = Table(tbl)
         return table
 
-    @pytest.fixture
-    def table_style_fixture(self):
-        style = 'foobar'
-        tbl = (
-            a_tbl().with_nsdecls().with_child(
-                a_tblPr().with_child(
-                    a_tblStyle().with_val(style)))
-        ).element
-        table = Table(tbl)
-        return table, style
-
-    @pytest.fixture
-    def table_style_set_fixture(self):
-        # table ------------------------
-        tbl = a_tbl().with_nsdecls().with_child(a_tblPr()).element
-        table = Table(tbl)
-        # style_name -------------------
-        style_name = 'foobar'
-        # expected_xml -----------------
-        expected_xml = (
-            a_tbl().with_nsdecls().with_child(
-                a_tblPr().with_child(
-                    a_tblStyle().with_val(style_name)))
-        ).xml()
-        return table, style_name, expected_xml
-
 
 class Describe_Cell(object):
 
     def it_provides_access_to_the_paragraphs_it_contains(
-            self, cell_with_paragraphs):
-        cell = cell_with_paragraphs
+            self, paragraphs_fixture):
+        cell = paragraphs_fixture
         paragraphs = cell.paragraphs
         assert len(paragraphs) == 2
-        for p in paragraphs:
-            assert isinstance(p, Paragraph)
+        count = 0
+        for idx, paragraph in enumerate(paragraphs):
+            assert isinstance(paragraph, Paragraph)
+            assert paragraph is paragraphs[idx]
+            count += 1
+        assert count == 2
 
     def it_can_replace_its_content_with_a_string_of_text(
-            self, cell_text_fixture):
-        cell, text, expected_xml = cell_text_fixture
+            self, text_set_fixture):
+        cell, text, expected_xml = text_set_fixture
         cell.text = text
         assert cell._tc.xml == expected_xml
 
     # fixtures -------------------------------------------------------
 
-    @pytest.fixture
-    def cell_text_fixture(self):
-        # cell -------------------------
-        tc = (
-            a_tc().with_nsdecls().with_child(
-                a_tcPr()).with_child(
-                a_p()).with_child(
-                a_tbl()).with_child(
-                a_p())
-        ).element
-        cell = _Cell(tc)
-        # text -------------------------
-        text = 'foobar'
-        # expected_xml -----------------
-        expected_xml = (
-            a_tc().with_nsdecls().with_child(
-                a_tcPr()).with_child(
-                a_p().with_child(
-                    an_r().with_child(
-                        a_t().with_text(text))))
-        ).xml()
-        return cell, text, expected_xml
+    @pytest.fixture(params=[
+        ('w:tc/w:p', 'foobar',
+         'w:tc/w:p/w:r/w:t"foobar"'),
+        ('w:tc/w:p', 'fo\tob\rar\n',
+         'w:tc/w:p/w:r/(w:t"fo",w:tab,w:t"ob",w:cr,w:t"ar",w:cr)'),
+        ('w:tc/(w:tcPr, w:p, w:tbl, w:p)', 'foobar',
+         'w:tc/(w:tcPr, w:p/w:r/w:t"foobar")'),
+    ])
+    def text_set_fixture(self, request):
+        tc_cxml, new_text, expected_cxml = request.param
+        cell = _Cell(element(tc_cxml))
+        expected_xml = xml(expected_cxml)
+        return cell, new_text, expected_xml
 
     @pytest.fixture
-    def cell_with_paragraphs(self):
-        tc = (
-            a_tc().with_nsdecls()
-                  .with_child(a_p())
-                  .with_child(a_p())
-                  .element
-        )
-        return _Cell(tc)
+    def paragraphs_fixture(self):
+        return _Cell(element('w:tc/(w:p, w:p)'))
 
 
 class Describe_Column(object):
 
-    def it_provides_access_to_the_column_cells(self, column):
+    def it_provides_access_to_the_column_cells(self):
+        column = _Column(None, None)
         cells = column.cells
         assert isinstance(cells, _ColumnCells)
 
@@ -181,43 +171,29 @@ def it_can_change_its_width(self, width_set_fixture):
     # fixtures -------------------------------------------------------
 
     @pytest.fixture(params=[
-        (4242,     2693670),
-        (1440,     914400),
-        ('2.54cm', 914400),
-        ('54mm',   1944000),
-        ('12.5pt', 158750),
-        (None,     None),
+        ('w:gridCol{w:w=4242}',   2693670),
+        ('w:gridCol{w:w=1440}',    914400),
+        ('w:gridCol{w:w=2.54cm}',  914400),
+        ('w:gridCol{w:w=54mm}',   1944000),
+        ('w:gridCol{w:w=12.5pt}',  158750),
+        ('w:gridCol',                None),
     ])
     def width_get_fixture(self, request):
-        w, expected_width = request.param
-        gridCol = self.gridCol_bldr(w).element
-        column = _Column(gridCol, None)
+        gridCol_cxml, expected_width = request.param
+        column = _Column(element(gridCol_cxml), None)
         return column, expected_width
 
     @pytest.fixture(params=[
-        (4242, None,   None),
-        (None, None,   None),
-        (4242, 914400, 1440),
-        (None, 914400, 1440),
+        ('w:gridCol',           914400, 'w:gridCol{w:w=1440}'),
+        ('w:gridCol{w:w=4242}', 457200, 'w:gridCol{w:w=720}'),
+        ('w:gridCol{w:w=4242}',   None, 'w:gridCol'),
+        ('w:gridCol',             None, 'w:gridCol'),
     ])
     def width_set_fixture(self, request):
-        initial_w, value, expected_w = request.param
-        gridCol = self.gridCol_bldr(initial_w).element
-        column = _Column(gridCol, None)
-        expected_xml = self.gridCol_bldr(expected_w).xml()
-        return column, value, expected_xml
-
-    # fixture components ---------------------------------------------
-
-    @pytest.fixture
-    def column(self):
-        return _Column(None, None)
-
-    def gridCol_bldr(self, w=None):
-        gridCol_bldr = a_gridCol().with_nsdecls()
-        if w is not None:
-            gridCol_bldr.with_w(w)
-        return gridCol_bldr
+        gridCol_cxml, new_value, expected_cxml = request.param
+        column = _Column(element(gridCol_cxml), None)
+        expected_xml = xml(expected_cxml)
+        return column, new_value, expected_xml
 
 
 class Describe_ColumnCells(object):
@@ -301,19 +277,11 @@ def columns_fixture(self):
 
 class Describe_Row(object):
 
-    def it_provides_access_to_the_row_cells(self, cells_access_fixture):
-        row = cells_access_fixture
+    def it_provides_access_to_the_row_cells(self):
+        row = _Row(element('w:tr'))
         cells = row.cells
         assert isinstance(cells, _RowCells)
 
-    # fixtures -------------------------------------------------------
-
-    @pytest.fixture
-    def cells_access_fixture(self):
-        tr = a_tr().with_nsdecls().element
-        row = _Row(tr)
-        return row
-
 
 class Describe_RowCells(object):
 
@@ -348,12 +316,8 @@ def it_raises_on_indexed_access_out_of_range(self, cell_count_fixture):
 
     @pytest.fixture
     def cell_count_fixture(self):
+        cells = _RowCells(element('w:tr/(w:tc, w:tc)'))
         cell_count = 2
-        tr_bldr = a_tr().with_nsdecls()
-        for idx in range(cell_count):
-            tr_bldr.with_child(a_tc())
-        tr = tr_bldr.element
-        cells = _RowCells(tr)
         return cells, cell_count
 
 
