Merge lp:~carifio/dotdepends/dotdepends-unittests into lp:dotdepends

[Mike Carifio]

Response to mfisch review, focused on unittests per kyleN direction.

[lp:~carifio/dotdepends/dotdepends-unittests]

74. By Mike Carifio on 2012-07-12

Response to LP: #1023564. Starts the unit test process for the Dot object.

75. By Mike Carifio on 2012-07-12

Dotdepends/__init__.py: Export class 'Dot'
test/test_Dot.py: Use Dotdepends.Dot directly.

[Kyle Nitzsche (knitzsche)]

1) line 141-44 (and throughout): style guide niggle: (https://dev.launchpad.net/PythonStyleGuide, section Multiline braces) arg/lists like this:
 mydict = {
        'first': 1,
        'second': 2,
        'third': 3,
        }

    mylist = [
        'this is the first line',
        'this is the second line',
        'this is the third line',
        ]

Instead of:
someting(asdn,asdfadf,adfasdf
    asdfadsf,asdfasdf,asdfsadf)

Note the opening and closing braces have no items/args on their lines. This makes for clearer diffs and less awkward line shortening too.

2) Created by 1023897 to track adding more unit tests to Dot.py as occasion permits us.

3) Can we use "not_a_package_12345" instead of "ima_baddy_bad_bad_bad_bad_ohohoh_XXXXXX"

3) are you intentinally writing "iff" (instead of "if") in comments many times

Unmerged revisions

78. By Mike Carifio on 2012-07-16

test/test_Dot.py:
  - Added test test_no_dot_file(), which expects to receive an exception when creating
    a Dot object with no path.

  - Added test test_no_dot_file_bad_path(), which does the same but this a file pathname.

  - Added -- and then skipped -- test test_no_contents(). This test tries to simulate a file
    with a string using StringIO. Unfortunately, Dot.__init__() expects a pathname, not a file
    handle, so this approach will fail. Need to more completely mock python files, which will
    have to wait.

77. By Mike Carifio on 2012-07-12

test/test_Dot.py: follow indentation standard for lists.

76. By Mike Carifio on 2012-07-12

test/test_Dot.py: spelling error

75. By Mike Carifio on 2012-07-12

Dotdepends/__init__.py: Export class 'Dot'
test/test_Dot.py: Use Dotdepends.Dot directly.

74. By Mike Carifio on 2012-07-12

Response to LP: #1023564. Starts the unit test process for the Dot object.

73. By Mike Carifio on 2012-07-11

Retain templates to seed future unit tests.
Right margin now column 78.
Created a utility method run_dotdepends that abstracts away calling the
dotdepends executable from the tests.

=== modified file 'Dotdepends/__init__.py'
--- Dotdepends/__init__.py	2012-06-19 19:20:52 +0000
+++ Dotdepends/__init__.py	2012-07-12 13:57:19 +0000
@@ -0,0 +1,3 @@
+import Dot
+# Allow import Dotdepends; d = Dotdepends.Dot('a/path')
+__all__ = ['Dot']

=== added file 'test/test_Dot.py'
--- test/test_Dot.py	1970-01-01 00:00:00 +0000
+++ test/test_Dot.py	2012-07-12 13:57:19 +0000
@@ -0,0 +1,76 @@
+#!/usr/bin/python
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 4 -*- ## emacs weenies
+
+# Copyright (C) 2012 Canonical, Ltd
+
+# Authors:
+#   Mike Carifio <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+
+import sys
+import os
+import unittest
+
+# Point at the objects under test.
+sys.path.insert(0,
+                os.path.abspath(
+                    os.path.dirname(os.path.abspath(__file__))
+                    + '/..'))
+# Point at (possible) supporting test code.
+sys.path.insert(0,
+                os.path.dirname(
+                    __file__)) # in case you're running in place
+
+
+#from Dotdepends import Dot
+import Dotdepends as D
+
+class DotTests(unittest.TestCase):
+    """Test the Dot class"""
+
+    # If this set changes in Dot, it should change here too.
+    bogus_char_set = set(['-', ':', '.', '+'])
+
+    def test_always_succeeds(self):
+        self.assertTrue(True, "tests the test runner")
+
+    def test_replacement(self):
+        for char in self.bogus_char_set:
+            for token in ['token0', 'with_underscore']:
+                bad = char + token + char + token + char
+                good = D.Dot.replacement(bad) # replace bogus chars
+                for replaced in self.bogus_char_set:
+                    self.assertTrue(good.find(replaced) == -1)
+
+    # TODO investigate the right pattern for exception testing
+    # TODO can python strings act as files?
+    def test_no_dot_file(self):
+        """Create Dot from nonexistant dot file raises exception"""
+        try:
+            d = D.Dot(None)
+            self.assertFalse(True, 'exception should have been raised')
+        except Exception, e: # TODO fix for python3
+            self.assertTrue(True, 'expecting an exception')
+
+
+# This sequence lets you run the test suite with python directly rather
+# than with a test runner indirectly.
+def main():
+    unittest.main()
+
+if __name__ == '__main__':
+    main()

=== modified file 'test/test_dotdepends_executable.py'
--- test/test_dotdepends_executable.py	2012-07-03 18:13:33 +0000
+++ test/test_dotdepends_executable.py	2012-07-12 13:57:19 +0000
@@ -22,15 +22,14 @@
 """
 test_dotdepends_executable -- tests dotdepends
 
-Unittests for the main program dotdepends (/usr/bin/dotdepends when installed).
+Unittests for the main program dotdepends (/usr/bin/dotdepends when
+installed).
 
 usage: python /path/to/test_dotdepends_executable.py
-       nosetests -v --exe -d /path/to/test ## run all tests, including this one
+       nosetests -v --exe -d /path/to/test ## run all tests,
+       including this one
 """
 
-
-
-
 import sys
 import os
 import subprocess
@@ -38,7 +37,9 @@
 import tempfile
 import shutil
 import unittest
-logging.basicConfig(level = logging.DEBUG) ## TODO: how can the test runner pass in args?
+
+logging.basicConfig(
+    level = logging.DEBUG) ## TODO: how can the test runner pass in args?
 
 # here: is the absolute path of where this test suite is running from.
 # Find 'here' now *before* you modify sys.path. Otherwise python reports
@@ -48,17 +49,19 @@
 
 # Point at the objects under test.
 sys.path.insert(0,
-    os.path.abspath(os.path.dirname(os.path.abspath(__file__))
-    + '/..'))
+                os.path.abspath(
+                    os.path.dirname(os.path.abspath(__file__))
+                    + '/..'))
 
 # Point at (possible) supporting test code.
-sys.path.insert( 0, os.path.dirname(__file__ ))
+sys.path.insert(0, os.path.dirname(__file__))
 
 
 class DotdependsExecutableTestcase(unittest.TestCase):
     """DotdependsExecutableTestcase
 
-    Run dotdepends on certain packages and with certain switches. This class needs more work.
+    Run dotdepends on certain packages and with certain switches. This
+    class needs more work.
 
     """
 
@@ -66,13 +69,28 @@
     working_directory = tempfile.mkdtemp()
     good_lower_pkg = 'debconf'
     good_upper_pkg = 'gedit'
-    bad_package = 'ima_baddy'
+    bad_package = 'ima_baddy_bad_bad_bad_bad_ohohoh_XXXXXX'
     dotdepends = here + '/../usr/bin/dotdepends'
 
     def dotdepends_path(self):
         return self.dotdepends
 
 
+    def run_dotdepends(self, command):
+        '''Utility method to run dotdepends executable "in place" as a
+        subprocess. Callers will test assertions after the call.
+
+        :param command: the switches to the dotdepends executable
+                                              """
+        :return: p: the subprocess, stdout, the output and stderr,
+        the standard error output
+        '''
+        p = subprocess.Popen(command, stdout = subprocess.PIPE,
+                             stderr = subprocess.PIPE)
+        stdout, stderr = p.communicate()
+        return p, stderr, stdout
+
+
     @classmethod
     def setUpClass(cls):
         # Move to the working directory.
@@ -82,11 +100,11 @@
 
     @classmethod
     def tearDownClass(cls):
-        # TODO: remove directory iff all tests pass. Currently removed regardless of test results.
+        # TODO: remove directory iff all tests pass. Currently removed
+        # regardless of test results.
         shutil.rmtree(cls.working_directory)
 
 
-
     # Name must be test_<something> so test runner can find them.
     def test_always_succeeds(self):
         """Always succeeds. Tests the test runner."""
@@ -98,11 +116,11 @@
         logging.debug("dotdepends: " + self.dotdepends_path())
         self.assertTrue(os.path.exists(self.dotdepends_path()))
 
+
     def test_dotdepends_installed(self):
         """dotdepends -i good_package => 1"""
-        command = [self.dotdepends_path(), '-i', self.good_lower_pkg ]
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        command = [ self.dotdepends_path(), '-i', self.good_lower_pkg ]
+        p, stderr, stdout = self.run_dotdepends(command)
         self.assertEquals(p.returncode, 1)
         self.assertTrue(stderr.startswith('Error.'))
         self.assertEqual(len(stdout), 0)
@@ -110,60 +128,58 @@
 
     def test_dotdepends_bad_switch(self):
         """dotdepends --invalid-switch good_pkg => 2"""
-        command = [ self.dotdepends_path(), '--invalid-switch', self.good_lower_pkg ]
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        command = [ self.dotdepends_path(), '--invalid-switch',
+                    self.good_lower_pkg ]
+        p, stderr, stdout = self.run_dotdepends(command)
         self.assertEquals(p.returncode, 2)
         self.assertEqual(len(stdout), 0)
 
     def test_dotdepends_mode_depends_switch_i(self):
-        command = [self.dotdepends_path(), '--installed', '-m', 'depends', self.good_lower_pkg ]
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        command = [ self.dotdepends_path(), '--installed', '-m', 'depends',
+                    self.good_lower_pkg ]
+        p, stderr, stdout = self.run_dotdepends(command)
         self.assertEquals(p.returncode, 1)
         self.assertEqual(len(stdout), 0)
 
     def test_dotdepends_mode_depends(self):
-        command = [self.dotdepends_path(), '-m', 'depends', self.good_lower_pkg ]
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        command = [ self.dotdepends_path(), '-m', 'depends',
+                    self.good_lower_pkg ]
+        p, stderr, stdout = self.run_dotdepends(command)
         self.assertEquals(p.returncode, 0)
         self.assertGreater(len(stdout), 0)
 
 
     def test_dotdepends_analyze(self):
         command = [ self.dotdepends_path(), self.good_lower_pkg ]
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        p, stderr, stdout = self.run_dotdepends(command)
         self.assertEquals(p.returncode, 0)
         self.assertGreater(len(stdout), 0)
 
 
     def test_dotdepends_bad_package(self):
         command = [ self.dotdepends_path(), self.bad_package ]
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        p, stderr, stdout = self.run_dotdepends(command)
         self.assertEquals(p.returncode, 1)
         self.assertEqual(len(stdout), 0)
-        self.assertFalse(os.path.exists(self.working_directory + os.path.sep + self.bad_package ))
+        self.assertFalse(os.path.exists(
+            self.working_directory + os.path.sep + self.bad_package))
 
 
     def test_dotdepends_rdepends(self):
-        command = [ self.dotdepends_path(), '-m', 'rdepends', self.good_upper_pkg ]
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        command = [ self.dotdepends_path(), '-m', 'rdepends',
+                    self.good_upper_pkg ]
+        p, stderr, stdout = self.run_dotdepends(command)
         self.assertEquals(p.returncode, 0)
         self.assertGreater(len(stdout), 0)
 
     def test_dotdepends_rdepends_installed_switch(self):
-        command = [ self.dotdepends_path(), '-m', 'rdepends', '-i', self.good_upper_pkg ]
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
-        stdout, stderr = p.communicate()
+        command = [ self.dotdepends_path(), '-m', 'rdepends', '-i',
+                    self.good_upper_pkg ]
+        p, stderr, stdout = self.run_dotdepends(command)
         self.assertEquals(p.returncode, 0)
         self.assertGreater(len(stdout), 0)
 
 
-
 # This sequence lets you run the test suite with python directly rather
 # than with a test runner indirectly.
 def main():

=== modified file 'test/test_template.py'
--- test/test_template.py	2012-06-26 15:24:39 +0000
+++ test/test_template.py	2012-07-12 13:57:19 +0000
@@ -36,11 +36,13 @@
 
 # Point at the objects under test.
 sys.path.insert(0,
-    os.path.abspath(os.path.dirname(os.path.abspath(__file__))
-    + '/..'))
+                os.path.abspath(
+                    os.path.dirname(os.path.abspath(__file__))
+                    + '/..'))
 # Point at (possible) supporting test code.
-sys.path.insert( 0,
-    os.path.dirname(__file__ ) ) # in case you're running in place
+sys.path.insert(0,
+                os.path.dirname(
+                    __file__)) # in case you're running in place
 
 
 # Name must be <Something>Tests so test runner can find it
@@ -59,7 +61,6 @@
         self.skipTest("skipping at runtime")
 
 
-
 # This sequence lets you run the test suite with python directly rather
 # than with a test runner indirectly.
 def main():

=== modified file 'test/test_template_executable.py'
--- test/test_template_executable.py	2012-07-02 17:37:34 +0000
+++ test/test_template_executable.py	2012-07-12 13:57:19 +0000
@@ -39,22 +39,25 @@
 
 # Point at the objects under test.
 sys.path.insert(0,
-    os.path.abspath(os.path.dirname(os.path.abspath(__file__))
-    + '/..'))
+                os.path.abspath(os.path.dirname(os.path.abspath(__file__))
+                + '/..'))
 # Point at (possible) supporting test code.
-sys.path.insert( 0,
-    os.path.dirname(__file__ ) ) # in case you're running in place
-
-me, _ = os.path.splitext(os.path.basename(__file__)) # name of this file, less .py
-
-logging.basicConfig(level = logging.DEBUG) ## TODO: how can the test runner pass in args?
+sys.path.insert(0,
+                os.path.dirname(__file__)) # in case you're running in place
+
+me, _ = os.path.splitext(
+    os.path.basename(__file__)) # name of this file, less .py
+
+logging.basicConfig(
+    level = logging.DEBUG) ## TODO: how can the test runner pass in args?
 
 # Name must be <Something>Tests so test runner can find it
 class TemplateExecutableTests(unittest.TestCase):
     """Describe the tests here"""
 
     # working_directory is a resource supporting the test
-    # Create it before the tests are run. Remove it after the tests are run iff
+    # Create it before the tests are run. Remove it after the tests are run
+    # iff
     #   all tests succeed.
     working_directory = mkdtemp()
 
@@ -70,7 +73,6 @@
         shutil.rmtree(cls.working_directory)
 
 
-
     # Name must be test_<something> so test runner can find them.
     def test_always_succeeds(self):
         """Always succeeds. Tests the test runner."""
@@ -86,17 +88,15 @@
         self.skipTest("skipping at runtime")
 
     def test_that_runs_an_external_executable(self):
-        command = ['ls', '-la', '/']
-        p = subprocess.Popen(command, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+        command = [ 'ls', '-la', '/' ]
+        p = subprocess.Popen(command, stdout = subprocess.PIPE,
+                             stderr = subprocess.PIPE)
         stdout, stderr = p.communicate()
         self.assertEquals(p.returncode, 0) # exit status 0
         self.assertEqual(stderr, '') # no errors reported to stderr
         self.assertGreater(len(stdout), 0) # should be some output
 
 
-
-
-
 # This sequence lets you run the test suite with python directly rather
 # than with a test runner indirectly.
 def main():