add tests, fix type handling

Author: michael-koeller

docx/opc/customprops.py

@@ -9,6 +9,7 @@
     absolute_import, division, print_function, unicode_literals
 )
 
+import numbers
 from lxml import etree
 
 NS_VT = "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
@@ -22,23 +23,47 @@ def __init__(self, element):
         self._element = element
 
     def __getitem__( self, item ):
-        # print(etree.tostring(self._element, pretty_print=True))
         prop = self.lookup(item)
         if prop is not None :
-            return prop[0].text
+            # print(etree.tostring(prop, pretty_print=True))
+            elm = prop[0]
+            if elm.tag == '{%s}i4' % NS_VT:
+                try:
+                    return int(elm.text)
+                except:
+                    return elm.text
+            elif elm.tag == '{%s}bool' % NS_VT:
+                return True if elm.text == '1' else False
+            return elm.text
 
     def __setitem__( self, key, value ):
         prop = self.lookup(key)
         if prop is None :
+            elmType = 'lpwstr'
+            if isinstance(value, bool):
+                elmType = 'bool'
+                value = str(1 if value else 0)
+            elif isinstance(value, numbers.Number):
+                elmType = 'i4'
+                value = str(int(value))
             prop = etree.SubElement( self._element, "property" )
-            elm = etree.SubElement(prop, '{%s}lpwstr' % NS_VT, nsmap = {'vt':NS_VT} )
+            elm = etree.SubElement(prop, '{%s}%s' %(NS_VT, elmType), nsmap = {'vt':NS_VT} )
+            elm.text = value
             prop.set("name", key)
             prop.set("fmtid", "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}")
             prop.set("pid", "%s" % str(len(self._element) + 1))
         else:
             elm = prop[0]
-        elm.text = value
-        # etree.tostring(prop, pretty_print=True)
+            if elm.tag == '{%s}i4' % NS_VT:
+                elm.text = str(int(value))
+            elif elm.tag == '{%s}bool' % NS_VT:
+                elm.text = str(1 if value else 0)
+            else:
+                elm.text = '%s' % str(value)
+        print(etree.tostring(prop, pretty_print=True))
+
+    def __len__( self ):
+        return len(self._element)
 
     def lookup(self, item):
         for child in self._element :

docx/oxml/__init__.py

@@ -39,6 +39,14 @@ def register_element_cls(tag, cls):
     namespace = element_class_lookup.get_namespace(nsmap[nspfx])
     namespace[tagroot] = cls
 
+def register_element_cls_ns(tag, ns, cls):
+    """
+    Register *cls* to be constructed when the oxml parser encounters an
+    element with matching *tag*. *tag* is a string of the form
+    ``nspfx:tagroot``, e.g. ``'w:document'``.
+    """
+    namespace = element_class_lookup.get_namespace(ns)
+    namespace[tag] = cls
 
 def OxmlElement(nsptag_str, attrs=None, nsdecls=None):
     """
@@ -73,7 +81,7 @@ def OxmlElement(nsptag_str, attrs=None, nsdecls=None):
 register_element_cls('cp:coreProperties', CT_CoreProperties)
 
 from .customprops import CT_CustomProperties  # noqa
-#register_element_cls('Properties', CT_CustomProperties)
+register_element_cls_ns('Properties', 'http://schemas.openxmlformats.org/officeDocument/2006/custom-properties', CT_CustomProperties)
 
 from .document import CT_Body, CT_Document  # noqa
 register_element_cls('w:body',     CT_Body)

docx/oxml/customprops.py

@@ -14,10 +14,11 @@
 from lxml import etree
 from .ns import nsdecls, qn
 from .xmlchemy import BaseOxmlElement, ZeroOrOne
+from . import parse_xml
 
 class CT_CustomProperties(BaseOxmlElement):
     """
-    ``<cp:customProperties>`` element, the root element of the Custom Properties
+    ``<Properties>`` element, the root element of the Custom Properties
     part stored as ``/docProps/custom.xml``. String elements are
     limited in length to 255 unicode characters.
     """
@@ -32,7 +33,7 @@ def new(cls):
         Return a new ``<property>`` element
         """
         xml = cls._customProperties_tmpl
-        customProperties = ct_parse_xml(xml)
+        customProperties = parse_xml(xml)
         return customProperties
 
     def _datetime_of_element(self, property_name):

features/doc-customprops.feature

@@ -0,0 +1,28 @@
+Feature: Read and write custom document properties
+  In order to find documents and make them manageable by digital means
+  As a developer using python-docx
+  I need to access and modify the Dublin Core metadata for a document
+
+
+  Scenario: read the custom properties of a document
+     Given a document having known custom properties
+      Then I can access the custom properties object
+       And the custom property values match the known values
+
+
+  Scenario: change the custom properties of a document
+     Given a document having known custom properties
+      When I assign new values to the custom properties
+      Then the custom property values match the new values
+
+
+  Scenario: a default custom properties part is added if doc doesn't have one
+     Given a document having no custom properties part
+      When I access the custom properties object
+      Then a custom properties part with no values is added
+
+
+  Scenario: set custom properties on a document that doesn't have one
+     Given a document having no custom properties part
+      When I assign new values to the custom properties
+      Then the custom property values match the new values

features/steps/customprops.py

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+"""
+Gherkin step implementations for custom properties-related features.
+"""
+
+from __future__ import (
+    absolute_import, division, print_function, unicode_literals
+)
+
+from datetime import datetime, timedelta
+
+from behave import given, then, when
+
+from docx import Document
+from docx.opc.customprops import CustomProperties
+
+from helpers import test_docx
+
+
+# given ===================================================
+
+@given('a document having known custom properties')
+def given_a_document_having_known_custom_properties(context):
+    context.document = Document(test_docx('doc-customprops'))
+
+
+@given('a document having no custom properties part')
+def given_a_document_having_no_custom_properties_part(context):
+    context.document = Document(test_docx('doc-no-customprops'))
+
+
+# when ====================================================
+
+@when('I access the custom properties object')
+def when_I_access_the_custom_properties_object(context):
+    context.document.custom_properties
+
+
+@when("I assign new values to the custom properties")
+def when_I_assign_new_values_to_the_custom_properties(context):
+    context.propvals = (
+        ('CustomPropBool',   False),
+        ('CustomPropInt',    1),
+        ('CustomPropString', 'Lorem ipsum'),
+    )
+    custom_properties = context.document.custom_properties
+    for name, value in context.propvals:
+        custom_properties[name] = value
+
+
+# then ====================================================
+
+@then('a custom properties part with no values is added')
+def then_a_custom_properties_part_with_no_values_is_added(context):
+    custom_properties = context.document.custom_properties
+    assert len(custom_properties) == 0
+
+
+@then('I can access the custom properties object')
+def then_I_can_access_the_custom_properties_object(context):
+    document = context.document
+    custom_properties = document.custom_properties
+    assert isinstance(custom_properties, CustomProperties)
+
+
+@then('the custom property values match the known values')
+def then_the_custom_property_values_match_the_known_values(context):
+    known_propvals = (
+        ('CustomPropBool',   True),
+        ('CustomPropInt',    13),
+        ('CustomPropString', 'Test String'),
+    )
+    custom_properties = context.document.custom_properties
+    for name, expected_value in known_propvals:
+        value = custom_properties[name]
+        assert value == expected_value, (
+            "got '%s' for custom property '%s'" % (value, name)
+        )
+
+
+@then('the custom property values match the new values')
+def then_the_custom_property_values_match_the_new_values(context):
+    custom_properties = context.document.custom_properties
+    for name, expected_value in context.propvals:
+        value = custom_properties[name]
+        assert value == expected_value, (
+            "got '%s' for custom property '%s'" % (value, name)
+        )

features/steps/test_files/doc-customprops.docx

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+"""
+Unit test suite for the docx.opc.parts.customprops module
+"""
+
+from __future__ import (
+    absolute_import, division, print_function, unicode_literals
+)
+
+from datetime import datetime, timedelta
+
+import pytest
+
+from docx.opc.customprops import CustomProperties
+from docx.opc.parts.customprops import CustomPropertiesPart
+from docx.oxml.customprops import CT_CustomProperties
+
+from ...unitutil.mock import class_mock, instance_mock
+
+
+class DescribeCustomPropertiesPart(object):
+
+    def it_provides_access_to_its_custom_props_object(self, customprops_fixture):
+        custom_properties_part, CustomProperties_ = customprops_fixture
+        custom_properties = custom_properties_part.custom_properties
+        CustomProperties_.assert_called_once_with(custom_properties_part.element)
+        assert isinstance(custom_properties, CustomProperties)
+
+    def it_can_create_a_default_custom_properties_part(self):
+        custom_properties_part = CustomPropertiesPart.default(None)
+        assert isinstance(custom_properties_part, CustomPropertiesPart)
+        custom_properties = custom_properties_part.custom_properties
+        assert len(custom_properties) == 0
+
+    # fixtures ---------------------------------------------
+
+    @pytest.fixture
+    def customprops_fixture(self, element_, CustomProperties_):
+        custom_properties_part = CustomPropertiesPart(None, None, element_, None)
+        return custom_properties_part, CustomProperties_
+
+    # fixture components -----------------------------------
+
+    @pytest.fixture
+    def CustomProperties_(self, request):
+        return class_mock(request, 'docx.opc.parts.customprops.CustomProperties')
+
+    @pytest.fixture
+    def element_(self, request):
+        return instance_mock(request, CT_CustomProperties)