[test] PEP8 cleanup of all files

Author: mpsonntag

test/test_bugs.py

@@ -1,6 +1,7 @@
-import odml
 import unittest
 
+import odml
+
 from odml.terminology import REPOSITORY
 
 

test/test_doc.py

@@ -96,8 +96,7 @@ def test_date(self):
 
     def test_get_terminology_equivalent(self):
         dir_path = os.path.dirname(os.path.realpath(__file__))
-        repo_file = os.path.join(dir_path, "resources",
-                                           "local_repository_file_v1.1.xml")
+        repo_file = os.path.join(dir_path, "resources", "local_repository_file_v1.1.xml")
         local_url = "file://%s" % pathname2url(repo_file)
 
         doc = Document(repository=local_url)
@@ -298,14 +297,14 @@ def test_create_section(self):
         self.assertEqual(len(root.sections), 0)
 
         name = "subsec"
-        type = "subtype"
+        sec_type = "subtype"
         oid = "79b613eb-a256-46bf-84f6-207df465b8f7"
-        subsec = root.create_section(name, type, oid)
+        subsec = root.create_section(name, sec_type, oid)
 
         self.assertEqual(len(root.sections), 1)
         self.assertEqual(subsec.parent, root)
         self.assertEqual(root.sections[name], subsec)
-        self.assertEqual(root.sections[name].type, type)
+        self.assertEqual(root.sections[name].type, sec_type)
         self.assertEqual(root.sections[name].oid, oid)
 
         name = "othersec"

test/test_dtypes.py

@@ -8,7 +8,7 @@
 
 class TestTypes(unittest.TestCase):
 
-    def assertLocalRegExp(self, text, regular_expression):
+    def assert_local_regexp(self, text, regular_expression):
         """
         Python 2 is dead and assertRegexpMatches is deprecated and
         will be removed, but keep compatibility until py 2 support is
@@ -20,9 +20,6 @@ def assertLocalRegExp(self, text, regular_expression):
         else:
             self.assertRegex(text, regular_expression)
 
-    def setUp(self):
-        pass
-
     def test_valid_type(self):
         # Test None
         self.assertTrue(typ.valid_type(None))
@@ -32,7 +29,7 @@ def test_valid_type(self):
             self.assertTrue(typ.valid_type(curr_type), "Invalid DType %s" % curr_type)
 
         # Test that provided shorthand dtypes return as valid dtypes.
-        for curr_shorthand in typ._dtype_map.keys():
+        for curr_shorthand in typ._dtype_map:
             self.assertTrue(typ.valid_type(curr_shorthand),
                             "Invalid dtype shorthand %s" % curr_shorthand)
 
@@ -49,9 +46,9 @@ def test_date(self):
         self.assertIsInstance(typ.date_get(None), datetime.date)
         self.assertIsInstance(typ.date_get(""), datetime.date)
 
-        re = "^[0-9]{4}-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1])$"
-        self.assertLocalRegExp(typ.date_get(None).strftime(typ.FORMAT_DATE), re)
-        self.assertLocalRegExp(typ.date_get("").strftime(typ.FORMAT_DATE), re)
+        reg = "^[0-9]{4}-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1])$"
+        self.assert_local_regexp(typ.date_get(None).strftime(typ.FORMAT_DATE), reg)
+        self.assert_local_regexp(typ.date_get("").strftime(typ.FORMAT_DATE), reg)
 
         date = datetime.date(2011, 12, 1)
         date_string = '2011-12-01'
@@ -81,9 +78,9 @@ def test_time(self):
         self.assertIsInstance(typ.time_get(None), datetime.time)
         self.assertIsInstance(typ.time_get(""), datetime.time)
 
-        re = "^[0-5][0-9]:[0-5][0-9]:[0-5][0-9]$"
-        self.assertLocalRegExp(typ.time_get(None).strftime(typ.FORMAT_TIME), re)
-        self.assertLocalRegExp(typ.time_get("").strftime(typ.FORMAT_TIME), re)
+        reg = "^[0-5][0-9]:[0-5][0-9]:[0-5][0-9]$"
+        self.assert_local_regexp(typ.time_get(None).strftime(typ.FORMAT_TIME), reg)
+        self.assert_local_regexp(typ.time_get("").strftime(typ.FORMAT_TIME), reg)
 
         time = datetime.time(12, 34, 56)
         time_string = '12:34:56'
@@ -113,10 +110,9 @@ def test_datetime(self):
         self.assertIsInstance(typ.datetime_get(None), datetime.datetime)
         self.assertIsInstance(typ.datetime_get(""), datetime.datetime)
 
-        re = "^[0-9]{4}-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1]) " \
-             "[0-5][0-9]:[0-5][0-9]:[0-5][0-9]$"
-        self.assertLocalRegExp(typ.datetime_get(None).strftime(typ.FORMAT_DATETIME), re)
-        self.assertLocalRegExp(typ.datetime_get("").strftime(typ.FORMAT_DATETIME), re)
+        reg = "^[0-9]{4}-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1]) [0-5][0-9]:[0-5][0-9]:[0-5][0-9]$"
+        self.assert_local_regexp(typ.datetime_get(None).strftime(typ.FORMAT_DATETIME), reg)
+        self.assert_local_regexp(typ.datetime_get("").strftime(typ.FORMAT_DATETIME), reg)
 
         date = datetime.datetime(2011, 12, 1, 12, 34, 56)
         date_string = '2011-12-01 12:34:56'

test/test_dumper.py

@@ -16,23 +16,23 @@ def setUp(self):
         s_type = "type"
 
         self.doc = odml.Document(author='Rave', version='1.0')
-        s1 = odml.Section(name='Cell', type=s_type)
-        p1 = odml.Property(name='Type', values='Rechargeable')
-        s1.append(p1)
+        sec1 = odml.Section(name='Cell', type=s_type)
+        prop1 = odml.Property(name='Type', values='Rechargeable')
+        sec1.append(prop1)
 
-        s2 = odml.Section(name='Electrolyte', type=s_type)
-        p2 = odml.Property(name='Composition', values='Ni-Cd')
-        s2.append(p2)
-        s1.append(s2)
+        sec2 = odml.Section(name='Electrolyte', type=s_type)
+        prop2 = odml.Property(name='Composition', values='Ni-Cd')
+        sec2.append(prop2)
+        sec1.append(sec2)
 
-        s3 = odml.Section(name='Electrode', type=s_type)
-        p3 = odml.Property(name='Material', values='Nickel')
-        p4 = odml.Property(name='Models', values=['AA', 'AAA'])
-        s3.append(p3)
-        s3.append(p4)
-        s2.append(s3)
+        sec3 = odml.Section(name='Electrode', type=s_type)
+        prop3 = odml.Property(name='Material', values='Nickel')
+        prop4 = odml.Property(name='Models', values=['AA', 'AAA'])
+        sec3.append(prop3)
+        sec3.append(prop4)
+        sec2.append(sec3)
 
-        self.doc.append(s1)
+        self.doc.append(sec1)
 
     def test_dump_doc(self):
         # Capture the output printed by the functions to STDOUT, and use it for
@@ -48,15 +48,14 @@ def test_dump_doc(self):
         # Reset stdout
         sys.stdout = sys.__stdout__
 
-        expected_output = []
-        expected_output.append("*Cell (type='type')")
-        expected_output.append(":Type (values=Rechargeable, dtype='string')")
-        expected_output.append("*Electrolyte (type='type')")
-        expected_output.append(":Composition (values=Ni-Cd, dtype='string')")
-        expected_output.append("*Electrode (type='type')")
-        expected_output.append(":Material (values=Nickel, dtype='string')")
-        expected_output.append(":Models (values=[AA,AAA], dtype='string')")
+        expected_output = ["*Cell (type='type')",
+                           ":Type (values=Rechargeable, dtype='string')",
+                           "*Electrolyte (type='type')",
+                           ":Composition (values=Ni-Cd, dtype='string')",
+                           "*Electrode (type='type')",
+                           ":Material (values=Nickel, dtype='string')",
+                           ":Models (values=[AA,AAA], dtype='string')"]
 
         self.assertEqual(len(output), len(expected_output))
-        for i in range(len(output)):
+        for i, _ in enumerate(output):
             self.assertEqual(output[i], expected_output[i])

test/test_fileio.py

@@ -10,7 +10,6 @@
 
 
 class TestTypes(unittest.TestCase):
-    # TODO :- Write tests for JSONParser once it's completed.
 
     def setUp(self):
         self.dir_path = os.path.dirname(os.path.realpath(__file__))
@@ -39,4 +38,3 @@ def test_invalid_parser(self):
 
         with self.assertRaises(NotImplementedError):
             odml.display(doc, 'html')
-

test/test_find_section.py

@@ -1,4 +1,5 @@
 import unittest
+
 from odml import Section
 
 

test/test_format_converter.py

@@ -141,4 +141,3 @@ def test_check_io_directory(self):
             FC._check_input_output_directory(in_dir, "/not_valid_path")
         self.assertNotRaises(FC._check_input_output_directory(in_dir, None))
         self.assertNotRaises(FC._check_input_output_directory(in_dir, out_dir))
-

test/test_infer_type.py

@@ -1,66 +1,66 @@
 import unittest
-import sys
+
 from datetime import datetime as dt, date, time
+
 from odml import Property, Section, Document
 from odml.tools.xmlparser import XMLReader, XMLWriter
 
+try:
+    unicode = unicode
+except NameError:
+    unicode = str
+
 
 class TestInferType(unittest.TestCase):
 
     def test_string(self):
-        p = Property("test", value="somestring")
-        assert(p.dtype == "string")
-        if sys.version_info < (3, 0):
-            assert isinstance(p.values[0], unicode)
-        else:
-            assert isinstance(p.values[0], str)
+        prop = Property("test", value="some_string")
+        self.assertEqual(prop.dtype, "string")
+        self.assertIsInstance(prop.values[0], unicode)
 
     def test_text(self):
-        p = Property("test", value="some\nstring")
-        assert(p.dtype == "text")
-        if sys.version_info < (3, 0):
-            assert isinstance(p.values[0], unicode)
-        else:
-            assert isinstance(p.values[0], str)
+        prop = Property("test", value="some\nstring")
+        self.assertEqual(prop.dtype, "text")
+        self.assertIsInstance(prop.values[0], unicode)
 
     def test_int(self):
-        p = Property("test", value=111)
-        assert(p.dtype == "int")
-        assert isinstance(p.values[0], int)
+        prop = Property("test", value=111)
+        self.assertEqual(prop.dtype, "int")
+        self.assertIsInstance(prop.values[0], int)
 
     def test_float(self):
-        p = Property("test", value=3.14)
-        assert(p.dtype == "float")
-        assert isinstance(p.values[0], float)
+        prop = Property("test", value=3.14)
+        self.assertEqual(prop.dtype, "float")
+        self.assertIsInstance(prop.values[0], float)
 
     def test_datetime(self):
-        p = Property("test", value=dt.now())
-        assert(p.dtype == "datetime")
-        assert isinstance(p.values[0], dt)
+        prop = Property("test", value=dt.now())
+        self.assertEqual(prop.dtype, "datetime")
+        self.assertIsInstance(prop.values[0], dt)
 
     def test_date(self):
-        p = Property("test", dt.now().date())
-        assert(p.dtype == "date")
-        assert isinstance(p.values[0], date)
+        prop = Property("test", dt.now().date())
+        self.assertEqual(prop.dtype, "date")
+        self.assertIsInstance(prop.values[0], date)
 
     def test_time(self):
-        p = Property("test", value=dt.now().time())
-        assert(p.dtype == "time")
-        assert isinstance(p.values[0], time)
+        prop = Property("test", value=dt.now().time())
+        self.assertEqual(prop.dtype, "time")
+        self.assertIsInstance(prop.values[0], time)
 
     def test_boolean(self):
-        p = Property("test", True)
-        assert(p.dtype == "boolean")
-        assert isinstance(p.values[0], bool)
+        prop = Property("test", True)
+        self.assertEqual(prop.dtype, "boolean")
+        self.assertIsInstance(prop.values[0], bool)
 
-        p = Property("test", False)
-        assert(p.dtype == "boolean")
-        assert isinstance(p.values[0], bool)
+        prop = Property("test", False)
+        self.assertEqual(prop.dtype, "boolean")
+        self.assertIsInstance(prop.values[0], bool)
 
     def test_read_write(self):
         doc = Document("author")
-        sec = Section("name", "type")
-        doc.append(sec)
+        sec = Section("name", "type", parent=doc)
+
         sec.append(Property("strprop", "somestring"))
         sec.append(Property("txtprop", "some\ntext"))
         sec.append(Property("intprop", 200))
@@ -69,47 +69,40 @@ def test_read_write(self):
         sec.append(Property("dateprop", dt.now().date()))
         sec.append(Property("timeprop", dt.now().time()))
         sec.append(Property("boolprop", True))
-        if sys.version_info < (3, 0):
-            str_doc = unicode(XMLWriter(doc))
-        else:
-            str_doc = str(XMLWriter(doc))
+
+        str_doc = unicode(XMLWriter(doc))
+
         new_doc = XMLReader().from_string(str_doc)
         new_sec = new_doc.sections[0]
 
-        p = new_sec.properties["strprop"]
-        assert(p.dtype == "string")
-        if sys.version_info < (3, 0):
-            assert isinstance(p.values[0], unicode)
-        else:
-            assert isinstance(p.values[0], str)
-
-        p = new_sec.properties["txtprop"]
-        assert(p.dtype == "text")
-        if sys.version_info < (3, 0):
-            assert isinstance(p.values[0], unicode)
-        else:
-            assert isinstance(p.values[0], str)
-
-        p = new_sec.properties["intprop"]
-        assert(p.dtype == "int")
-        assert isinstance(p.values[0], int)
-
-        p = new_sec.properties["floatprop"]
-        assert(p.dtype == "float")
-        assert isinstance(p.values[0], float)
-
-        p = new_sec.properties["datetimeprop"]
-        assert(p.dtype == "datetime")
-        assert isinstance(p.values[0], dt)
-
-        p = new_sec.properties["dateprop"]
-        assert(p.dtype == "date")
-        assert isinstance(p.values[0], date)
-
-        p = new_sec.properties["timeprop"]
-        assert(p.dtype == "time")
-        assert isinstance(p.values[0], time)
-
-        p = new_sec.properties["boolprop"]
-        assert(p.dtype == "boolean")
-        assert isinstance(p.values[0], bool)
+        prop = new_sec.properties["strprop"]
+        self.assertEqual(prop.dtype, "string")
+        self.assertIsInstance(prop.values[0], unicode)
+
+        prop = new_sec.properties["txtprop"]
+        self.assertEqual(prop.dtype, "text")
+        self.assertIsInstance(prop.values[0], unicode)
+
+        prop = new_sec.properties["intprop"]
+        self.assertEqual(prop.dtype, "int")
+        self.assertIsInstance(prop.values[0], int)
+
+        prop = new_sec.properties["floatprop"]
+        self.assertEqual(prop.dtype, "float")
+        self.assertIsInstance(prop.values[0], float)
+
+        prop = new_sec.properties["datetimeprop"]
+        self.assertEqual(prop.dtype, "datetime")
+        self.assertIsInstance(prop.values[0], dt)
+
+        prop = new_sec.properties["dateprop"]
+        self.assertEqual(prop.dtype, "date")
+        self.assertIsInstance(prop.values[0], date)
+
+        prop = new_sec.properties["timeprop"]
+        self.assertEqual(prop.dtype, "time")
+        self.assertIsInstance(prop.values[0], time)
+
+        prop = new_sec.properties["boolprop"]
+        self.assertEqual(prop.dtype, "boolean")
+        self.assertIsInstance(prop.values[0], bool)