Add testing support for cvs2svn

test.py

 #!/usr/bin/env python
 
 """Wrapper script for running all of Unladen Swallow's third-party tests.
 
 This is equivalent to manually invoking the tests for each third-party app/lib.
 Note that this script is intended to be invoked after setup.py install (certain)
 tests depend on it.
 """
 
 __author__ = "collinwinter@google.com (Collin Winter)"
@@ skipping 83 matching lines @@
 
 
 def CallAndCaptureOutput(command, env=None):
     """Run the given command, capturing stdout and stderr.
 
     Args:
         command: the command to run as a list, one argument per element.
         env: optional; dict of environment variables to set.
 
     Returns:
-        The captured stdout + stderr as a string.
+        (output, retcode) where output is captured stdout + stderr as a string;
+        retcode is the process's return code.
 
     Raises:
         RuntimeError: if the command failed. The value of the exception will
         be the error message from the command.
     """
     subproc = subprocess.Popen(command,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE,
                                env=BuildEnv(env))
     with BuildBotMollifier():
         result, err = subproc.communicate()
     print result + err,
-    return result + err
+    return (result + err, subproc.returncode)
 
 
 def DefaultPassCheck(command, env=None):
     """Run a test command and check whether it passed.
 
     This works for most test suites we run, but not all. Pass/fail is
     determined by whether the final line of output starts with OK.
 
     Args:
         command: the command to run as a list, one argument per element.
         env: optional; dict of environment variables to set.
 
     Returns:
         True if the test passed, False otherwise.
     """
-    output = CallAndCaptureOutput(command, env)
+    output, _ = CallAndCaptureOutput(command, env)
     lines = output.splitlines()
     if not lines:
         return False
     return lines[-1].startswith("OK")
 
 
+def CheckReturnCode(command):
+    output, ret_code = CallAndCaptureOutput(command)
+    return ret_code == 0
+
+
 ### Wrappers for the third-party modules we don't want to break go here. ###
 
 def Test2to3():
     return DefaultPassCheck([sys.executable, "-E", "test.py"])
 
 def TestCheetah():
     path = os.pathsep.join([os.environ["PATH"],
                             os.path.dirname(sys.executable)])
     with ChangeDir(os.path.join("src", "Tests")):
         return DefaultPassCheck([sys.executable, "-E", "Test.py"],
                                 env={"PATH": path})
+
+def TestCvs2svn():
+    return CheckReturnCode([sys.executable, "-E", "run-tests.py", "-v"])

[Jeffrey Yasskin, 2009/07/03 05:25:35]

We probably want to print the output on failure.

[Collin Winter, 2009/07/04 03:59:02]

On 2009/07/03 05:25:35, Jeffrey Yasskin wrote:
> We probably want to print the output on failure.

Yep, CallAndCaptureOutput() already does that.

 
 def TestDjango():
     py_path = os.path.join("..", "..", "correctness")
     test_runner = os.path.join("tests", "runtests.py")
     return DefaultPassCheck([sys.executable, test_runner, "-v1",
                              "--settings=django_data.settings"],
                             env={"PYTHONPATH": py_path})
 
 # Mercurial's test are disabled. They fail on Ubuntu Hardy, are flaky on
 # Dapper and OS X and take forever to run.
 # def TestMercurial():
 #     with ChangeDir("tests"):
 #         output = CallAndCaptureOutput([sys.executable, "-E", "run-tests.py"])
 #         lines = output.splitlines()
 #         return lines[-1].endswith(" 0 failed.")
 
 def TestNose():
     return DefaultPassCheck([sys.executable, "-E", "selftest.py"])
 
 def TestNumpy():
     # Numpy refuses to be imported from the source directory.
     with ChangeDir(".."):
         return DefaultPassCheck([sys.executable, "-E", "-c",
                                  "import numpy; numpy.test()"])
 
 def TestPyxml():
     with ChangeDir("test"):
-        output = CallAndCaptureOutput([sys.executable, "-E", "regrtest.py"])
+        output, _ = CallAndCaptureOutput([sys.executable, "-E", "regrtest.py"])
         lines = output.splitlines()
         return lines[-1].endswith("OK.")
 
 def TestSetuptools():
     return DefaultPassCheck([sys.executable, "-E", "setup.py", "test"])
 
 def TestSwig():
-    ret_code = subprocess.call(["make", "check"])
-    return ret_code == 0
+    return CheckReturnCode(["make", "check"])
 
 def TestSympy():
-    output = CallAndCaptureOutput([sys.executable, "-E", "setup.py", "test"])
+    output, _ = CallAndCaptureOutput([sys.executable, "-E", "setup.py", "test"])
     return not output.endswith("DO *NOT* COMMIT!\n")
 
 def TestZope_interface():
     # zope.interface is included because Twisted and a number of Zope packages
     # depend on it.
     return DefaultPassCheck([sys.executable, "-E", "setup.py", "test",
                              "-s", "zope.interface.tests"])
 
 
 ### Utility code ###
@@ skipping 31 matching lines @@
             tests_passed[test_name] = test_func()
         finally:
             os.chdir(current_dir)
 
     if all(tests_passed.values()):
         print "All OK"
     else:
         failed = [test for (test, passed) in tests_passed.items() if not passed]
         print "FAILED:", failed
         sys.exit(1)