removing all support for mongo-qa tests

Mike Dirolf · Mike Dirolf · commit 54be5db873ab · 2010-01-05T14:20:12.000-05:00
allows us to remove SON.from_xml
  - not deprecating this as it was used internally only AFAIK

therefore eliminates driver dependency on elementtree
diff --git a/README.rst b/README.rst
@@ -22,7 +22,6 @@ C extension will not be built. This will negatively affect performance, but ever
 
 Additional dependencies are:
 
-- `ElementTree <http://effbot.org/zone/element-index.htm>`_ (this is included with Python >= 2.5)
 - (to generate documentation) sphinx_
 - (to auto-discover tests) `nose <http://somethingaboutorange.com/mrl/projects/nose/>`_
 
diff --git a/pymongo/errors.py b/pymongo/errors.py
@@ -61,6 +61,7 @@ class InvalidBSON(ValueError):
     """Raised when trying to create a BSON object from invalid data.
     """
 
+
 class InvalidStringData(ValueError):
     """Raised when trying to encode a string containing non-UTF8 data.
     """
@@ -71,11 +72,6 @@ class InvalidDocument(ValueError):
     """
 
 
-class UnsupportedTag(ValueError):
-    """Raised when trying to parse an unsupported tag in an XML document.
-    """
-
-
 class InvalidId(ValueError):
     """Raised when trying to create an ObjectId from invalid data.
     """
diff --git a/pymongo/son.py b/pymongo/son.py
@@ -18,12 +18,6 @@
 of keys is important. A SON object can be used just like a normal Python
 dictionary."""
 
-import datetime
-import re
-import binascii
-import base64
-import types
-
 
 class SON(dict):
     """SON data.
@@ -190,7 +184,6 @@ def __cmp__(self, other):
     def __len__(self):
         return len(self.keys())
 
-    # Thanks to Jeff Jenkins for the idea and original implementation
     def to_dict(self):
         """Convert a SON document to a normal Python dictionary instance.
 
@@ -199,129 +192,13 @@ def to_dict(self):
         """
 
         def transform_value(value):
-            if isinstance(value, types.ListType):
+            if isinstance(value, list):
                 return [transform_value(v) for v in value]
             if isinstance(value, SON):
                 value = dict(value)
-            if isinstance(value, types.DictType):
+            if isinstance(value, dict):
                 for k, v in value.iteritems():
                     value[k] = transform_value(v)
             return value
 
         return transform_value(dict(self))
-
-    def from_xml(cls, xml):
-        """Create an instance of SON from an xml document.
-
-        This is really only used for testing, and is probably unnecessary.
-        """
-        try:
-            import xml.etree.ElementTree as ET
-        except ImportError:
-            import elementtree.ElementTree as ET
-
-        from code import Code
-        from binary import Binary
-        from objectid import ObjectId
-        from dbref import DBRef
-        from errors import UnsupportedTag
-
-        def pad(list, index):
-            while index >= len(list):
-                list.append(None)
-
-        def make_array(array):
-            doc = make_doc(array)
-            array = []
-            for (key, value) in doc.items():
-                index = int(key)
-                pad(array, index)
-                array[index] = value
-            return array
-
-        def make_string(string):
-            return string.text is not None and unicode(string.text) or u""
-
-        def make_code(code):
-            return code.text is not None and Code(code.text) or Code("")
-
-        def make_binary(binary):
-            if binary.text is not None:
-                return Binary(base64.decodestring(binary.text))
-            return Binary("")
-
-        def make_boolean(bool):
-            return bool.text == "true"
-
-        def make_date(date):
-            return datetime.datetime.utcfromtimestamp(float(date.text) /
-                                                      1000.0)
-
-        def make_ref(dbref):
-            return DBRef(make_elem(dbref[0]), make_elem(dbref[1]))
-
-        def make_oid(oid):
-            return ObjectId(binascii.unhexlify(oid.text))
-
-        def make_int(data):
-            return int(data.text)
-
-        def make_null(null):
-            return None
-
-        def make_number(number):
-            return float(number.text)
-
-        def make_regex(regex):
-            return re.compile(make_elem(regex[0]), make_elem(regex[1]))
-
-        def make_options(data):
-            options = 0
-            if not data.text:
-                return options
-            if "i" in data.text:
-                options |= re.IGNORECASE
-            if "l" in data.text:
-                options |= re.LOCALE
-            if "m" in data.text:
-                options |= re.MULTILINE
-            if "s" in data.text:
-                options |= re.DOTALL
-            if "u" in data.text:
-                options |= re.UNICODE
-            if "x" in data.text:
-                options |= re.VERBOSE
-            return options
-
-        def make_elem(elem):
-            try:
-                return {"array": make_array,
-                        "doc": make_doc,
-                        "string": make_string,
-                        "binary": make_binary,
-                        "boolean": make_boolean,
-                        "code": make_code,
-                        "date": make_date,
-                        "ref": make_ref,
-                        "ns": make_string,
-                        "oid": make_oid,
-                        "int": make_int,
-                        "null": make_null,
-                        "number": make_number,
-                        "pattern": make_string,
-                        "options": make_options,
-                        }[elem.tag](elem)
-            except KeyError:
-                raise UnsupportedTag("cannot parse tag: %s" % elem.tag)
-
-        def make_doc(doc):
-            son = SON()
-            for elem in doc:
-                son[elem.attrib["name"]] = make_elem(elem)
-            return son
-
-        tree = ET.XML(xml)
-        doc = tree[1]
-
-        return make_doc(doc)
-    from_xml = classmethod(from_xml)
diff --git a/setup.py b/setup.py
@@ -21,15 +21,6 @@
 
 from pymongo import version
 
-requirements = []
-try:
-    import xml.etree.ElementTree
-except ImportError:
-    try:
-        import elementtree
-    except ImportError:
-        requirements.append("elementtree")
-
 f = open("README.rst")
 try:
     try:
@@ -158,7 +149,7 @@ def build_extension(self, ext):
     url="http://github.com/mongodb/mongo-python-driver",
     keywords=["mongo", "mongodb", "pymongo", "gridfs"],
     packages=["pymongo", "gridfs"],
-    install_requires=requirements,
+    install_requires=[],
     features=features,
     license="Apache License, Version 2.0",
     test_suite="nose.collector",
diff --git a/test/test_bson.py b/test/test_bson.py
@@ -19,28 +19,24 @@
 import unittest
 import datetime
 import re
-import glob
 import sys
-import types
-
 try:
     import uuid
     should_test_uuid = True
 except ImportError:
     should_test_uuid = False
+sys.path[0:0] = [""]
 
 from nose.plugins.skip import SkipTest
 
-sys.path[0:0] = [""]
-
 import qcheck
 from pymongo.binary import Binary
 from pymongo.code import Code
 from pymongo.objectid import ObjectId
 from pymongo.dbref import DBRef
 from pymongo.son import SON
 from pymongo.bson import BSON, is_valid, _to_dicts
-from pymongo.errors import UnsupportedTag, InvalidDocument, InvalidStringData
+from pymongo.errors import InvalidDocument, InvalidStringData
 
 
 class TestBSON(unittest.TestCase):
@@ -149,7 +145,7 @@ def helper(dict):
         helper({"test": u"hello"})
         self.assert_(isinstance(BSON.from_dict({"hello": "world"})
                                 .to_dict()["hello"],
-                                   types.UnicodeType))
+                                unicode))
         helper({"mike": -10120})
         helper({"long": long(10)})
         helper({"really big long": 2147483648})
@@ -173,43 +169,6 @@ def from_then_to_dict(dict):
         qcheck.check_unittest(self, from_then_to_dict,
                               qcheck.gen_mongo_dict(3))
 
-    def test_data_files(self):
-        # TODO don't hardcode this, actually clone the repo
-        data_files = "../mongo-qa/modules/bson_tests/tests/*/*.xson"
-        generate = True
-
-        for file_name in glob.glob(data_files):
-            f = open(file_name, "r")
-            xml = f.read()
-            f.close()
-
-            try:
-                doc = SON.from_xml(xml)
-                bson = BSON.from_dict(doc)
-            except UnsupportedTag:
-                print "skipped file %s: %s" % (file_name, sys.exc_info()[1])
-                continue
-
-            try:
-                f = open(file_name.replace(".xson", ".bson"), "rb")
-                expected = f.read()
-                f.close()
-
-                self.assertEqual(bson, expected,
-                                 "(in %s) %r != %r" % (file_name, bson,
-                                                       expected))
-                self.assertEqual(doc, bson.to_dict(),
-                                 "(in %s) %r != %r" % (file_name, doc,
-                                                       bson.to_dict()))
-
-            except IOError:
-                if generate:
-                    print "generating .bson for %s" % file_name
-
-                    f = open(file_name.replace(".xson", ".bson"), "w")
-                    f.write(bson)
-                    f.close()
-
     def test_bad_encode(self):
         self.assertRaises(InvalidStringData, BSON.from_dict,
                           {"lalala": '\xf4\xe0\xf0\xe1\xc0 Color Touch'})
diff --git a/test/test_son.py b/test/test_son.py
@@ -15,15 +15,10 @@
 """Tests for the son module."""
 
 import unittest
-import datetime
-import re
 import sys
 sys.path[0:0] = [""]
 
-from pymongo.objectid import ObjectId
-from pymongo.dbref import DBRef
 from pymongo.son import SON
-from pymongo.code import Code
 
 
 class TestSON(unittest.TestCase):
@@ -58,52 +53,6 @@ def test_to_dict(self):
         self.assertEqual(dict, c.to_dict()["blah"][0].__class__)
         self.assertEqual(dict, d.to_dict()["blah"]["foo"].__class__)
 
-    def test_from_xml(self):
-        smorgasbord = """
-<twonk>
-  <meta/>
-  <doc>
-    <oid name="_id">285a664923b5fcd8ec000000</oid>
-    <int name="the_answer">42</int>
-    <string name="b">foo</string>
-    <boolean name="c">true</boolean>
-    <number name="pi">3.14159265358979</number>
-    <array name="an_array">
-      <string name="0">x</string>
-      <string name="1">y</string>
-      <string name="2">z</string>
-      <doc name="3">
-        <string name="subobject">yup</string>
-      </doc>
-    </array>
-    <date name="now">123144452057</date>
-    <ref name="dbref">
-      <ns>namespace</ns>
-      <oid>ca5c67496c01d896f7010000</oid>
-    </ref>
-    <code name="$where">this is code</code>
-    <null name="mynull"/>
-  </doc>
-</twonk>
-"""
-        self.assertEqual(SON.from_xml(smorgasbord),
-                         SON([(u"_id", ObjectId("\x28\x5A\x66\x49\x23\xB5\xFC"
-                                                "\xD8\xEC\x00\x00\x00")),
-                              (u"the_answer", 42),
-                              (u"b", u"foo"),
-                              (u"c", True),
-                              (u"pi", 3.14159265358979),
-                              (u"an_array", [u"x", u"y", u"z",
-                                             SON([(u"subobject", u"yup")])]),
-                              (u"now", datetime.datetime(1973, 11, 26, 6,
-                                                         47, 32, 57000)),
-                              (u"dbref",
-                               DBRef("namespace",
-                                     ObjectId("\xCA\x5C\x67\x49\x6C\x01"
-                                              "\xD8\x96\xF7\x01\x00\x00"))),
-                              (u"$where", Code("this is code")),
-                              (u"mynull", None),
-                              ]))
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tools/README.rst b/tools/README.rst
@@ -1,13 +1,3 @@
 Tools
 =====
 This directory contains tools for use with the ``pymongo`` module.
-
-validate and validate.py
-========================
-These scripts are used by 10gen's driver testing tools to verify the
-correctness of ``pymongo`` BSON module (``pymongo.bson``).
-
-driver_tests.py
-===============
-This script is used by 10gen's
-`driver testing framework. <http://mongodb.onconfluence.com/display/DOCS/Mongo+Driver+Test+Framework>`_
diff --git a/tools/driver_tests.py b/tools/driver_tests.py
diff --git a/tools/validate b/tools/validate
diff --git a/tools/validate.py b/tools/validate.py
