Merge lp:~jml/testtools/more-content-convenience into lp:~testtools-committers/testtools/trunk

[Jonathan Lange]

This branch adds a bunch of convenience methods for the content APIs.

Specifically,
 * Content.from_file, which makes a Content object based on file contents
 * Content.from_stream, which makes a Content object based on stream contents
 * TestCase.attachFile(name, *args), which is TestCase.addDetail(name, Content.from_file(*args))

I've also made Content.from_text, and made the text_content function a simple pointer to that.

There's some duplication between from_file and from_stream. Not sure what to do about that.

I added the eager loading (aka read_now) option because there's code in Launchpad that explicitly does eager loading in order to avoid bad interaction between fixture tear down and addDetail. Not sure if it should be the default.

I also don't know what the default chunk size should be. The value I've chosen is almost certainly wrong.

[Robert Collins (lifeless)]

Meta: I think these would be better as stand alone functions rather
than class methods.

>  * TestCase.attachFile(name, *args), which is TestCase.addDetail(name, Content.from_file(*args))

I worry a little about expanding the TestCase contract; I won't block
this, but I think it would be clearer not to have an attachFile
method.

> I've also made Content.from_text, and made the text_content function a simple pointer to that.
>
> There's some duplication between from_file and from_stream. Not sure what to do about that.

I would address that by having a 'stream' fixture handed into a common
function, and both delegate to that - one can use a trivial lambda,
the other case opens a file and closes it.

Theres a lifetime ambiguity about from_stream - except for StringIO,
who will close the stream? We should document that, and how to handle
it.

The eager loading thing is fine I think, except that all the other
logic becomes irrelevant so it really should be a separate codepath
for the file case (because chunking on read-now is pointless), and the
stream case can be ignored - clients can call .read() instead - that
will be clearer.

I haven't looked at the tests in detail, I'm sure they will be fine
supporting cases for the changes you've made.

-Rob

[Jonathan Lange (jml)]

 * I've dropped attachFile. We can add it later if the people clamor for it.

 * I don't think they'd be better as stand-alone functions. At the very least, standalone functions can be implemented in terms of classmethods (e.g. content_from_file = Content.from_file), but classmethods can only be built from functions if they drop the class-based dispatch. As far as I can tell, it's a matter of taste. I am willing to budge on this one.

 * I've added documentation to from_stream saying that it will close the stream when the iterator is exhausted, and made it actually close the stream. The reasoning is that testtools doesn't really offer any sort of hook for a sensible place to close the stream.

 * I've dropped the read_now path from from_stream.

 * I've changed the read_now path in from_file to be completely separate from the lazy read path.

 * I couldn't get the fixture thing to work.

Unfortunately, without attachFile, we still don't have a nice syntax for the common case of "add this file as a detail during teardown". The best we have is:
  self.addCleanup(lambda: self.addDetail('foo', Content.from_file('foo.txt', read_now=True)))

As opposed to:
  self.addCleanup(self.attachFile, 'foo', 'foo.txt', read_now=True)

I'm going to go away and think some more.

[Robert Collins (lifeless)]

Will look at the code todayish.

On Fri, Dec 31, 2010 at 3:38 AM, Jonathan Lange <email address hidden> wrote:
>  * I've dropped attachFile. We can add it later if the people clamor for it.
>
>  * I don't think they'd be better as stand-alone functions.  At the very least, standalone functions can be implemented in terms of classmethods (e.g. content_from_file = Content.from_file), but classmethods can only be built from functions if they drop the class-based dispatch.  As far as I can tell, it's a matter of taste.  I am willing to budge on this one.

I think doing 'TracebackContent.from_file' would be hugely confusing.
I'll see about whipping up a comparitive patch.

>  * I've added documentation to from_stream saying that it will close the stream when the iterator is exhausted, and made it actually close the stream.  The reasoning is that testtools doesn't really offer any sort of hook for a sensible place to close the stream.

>  * I've changed the read_now path in from_file to be completely separate from the lazy read path.
>
>  * I couldn't get the fixture thing to work.

What didn't work?

> Unfortunately, without attachFile, we still don't have a nice syntax for the common case of "add this file as a detail during teardown".  The best we have is:
>  self.addCleanup(lambda: self.addDetail('foo', Content.from_file('foo.txt', read_now=True)))
>
> As opposed to:
>  self.addCleanup(self.attachFile, 'foo', 'foo.txt', read_now=True)

I see, the lambda is needed because we want to force Content.from_file
to execute at cleanup time, not before.

And what we're really saying is 'try to read this thing during
cleanup, and cache the result cause its going to get deleted'.

So there are a few related bits here; the first is that the case I
expect this to happen in, is the case where the file being read is a
log file for a temporary server. I'd expect that server to have a
fixture, and the fixtures /details/ will be automatically captured
during cleanup. So the place that 'attachFile during cleanup' as a
convenience method is most needed is in fixtures. or somewhere where
it is usable by both TestCase and Fixture.

def attach_file(path, obj_with_details, name=None, lazy_read=False):
     """Attach the contents of the file at path to obj_with_details.

     This function adds a 'details' object to obj_with_details which will
     return the content of path. By default the content is read immediately
     and cached.

    :param path: The path of the file.
    :param obj_with_details: The object to attach the file to -
generally a TestCase or Fixture.
    :param name: Optional name for the file. If not specified the
basename is used.
    :param lazy_read: If True the file content is not read when
attach_file is called, but later
        when the content object is evaluated. Note that this may be
after any cleanups that
        obj_with_details has, so if the file is a temporary file
lazy_read may cause the file to
        be read after it is deleted. To handle those cases, using
attach_file as a cleanup is
        recommended::
             obj_with_details.addCleanUp(attach_file, 'foo.txt',
obj_with_details)
    :return: None
    """

[lp:~jml/testtools/more-content-convenience]

179. By Jonathan Lange on 2011-02-01

Merge trunk.

180. By Jonathan Lange on 2011-02-01

Copyright bump

181. By Jonathan Lange on 2011-02-01

Delete from_text.

182. By Jonathan Lange on 2011-02-01

Move Content.from_stream to be content_from_stream

183. By Jonathan Lange on 2011-02-01

Fix up the documentation.

184. By Jonathan Lange on 2011-02-01

Move attachFile from TestCase to be a standalone function.

185. By Jonathan Lange on 2011-02-01

Change the order of parameters to attach_file

186. By Jonathan Lange on 2011-02-01

read_now => lazy_read, as per review.

187. By Jonathan Lange on 2011-02-01

More tests for attach_file, make lazy read work.

[Jonathan Lange (jml)]

I couldn't make the code look better by using fixtures. They just made it more cumbersome.

I've changed the classmethods to be functions (although I still think it looks uglier), and I've changed attachFile to be a standalone function too. I still think TestCase would benefit from a convenience method, but this is still a net improvement.

[Robert Collins (lifeless)]

I've push up a riff on your branch - lp:~lifeless/testtools/details - if you like that, just land it. Otherwise lets chat on IRC/voice now that I've refreshed the branch in my head.

[Robert Collins (lifeless)]

(if you like my riff, land with the riff)

[Jonathan Lange (jml)]

In a nutshell,
 * I like content_from_reader
 * I think the decorator-for-default-args things is kind of neat
 * But I also think it's a bit too clever (it is also missing tests)

Will probably land with your riff sans decorator.

[Jonathan Lange (jml)]

Riff (lp:~lifeless/testtools/details) landed sans decorator.

=== modified file 'NEWS'
--- NEWS	2011-01-22 16:47:31 +0000
+++ NEWS	2011-02-01 18:58:11 +0000
@@ -24,6 +24,10 @@
 
 * ``MultiTestResult`` now documented in the manual. (Jonathan Lange, #661116)
 
+* New content helpers ``content_from_file``, ``content_from_stream`` and
+  ``attach_file`` make it easier to attach file-like objects to a
+  test. (Jonathan Lange, #694126)
+
 * New ``ExpectedException`` context manager to help write tests against things
   that are expected to raise exceptions. (Aaron Bentley)
 
 
=== modified file 'doc/for-test-authors.rst'
--- doc/for-test-authors.rst	2011-01-22 16:47:31 +0000
+++ doc/for-test-authors.rst	2011-02-01 18:58:11 +0000
@@ -737,6 +737,10 @@
 
   image = Content(ContentType('image', 'png'), lambda: open('foo.png').read())
 
+Or you could use the convenience function::
+
+  image = content_from_file('foo.png', ContentType('image', 'png'))
+
 The ``lambda`` helps make sure that the file is opened and the actual bytes
 read only when they are needed – by default, when the test is finished.  This
 means that tests can construct and add Content objects freely without worrying
@@ -754,7 +758,7 @@
 might do it::
 
   from testtools import TestCase
-  from testtools.content import Content
+  from testtools.content import attach_file, Content
   from testtools.content_type import UTF8_TEXT
 
   from myproject import SomeServer
@@ -766,7 +770,7 @@
           self.server = SomeServer()
           self.server.start_up()
           self.addCleanup(self.server.shut_down)
-          self.addCleanup(self.attach_log_file)
+          self.addCleanup(attach_file, self.server.logfile, self)
 
       def attach_log_file(self):
           self.addDetail(
@@ -781,10 +785,6 @@
 run.  testtools will only display the log file for failing tests, so it's not
 such a big deal.
 
-Note the callable passed to ``Content`` reads the log file line-by-line.  This
-is something of an optimization.  If we naively returned all of the log file
-as one bytestring, ``Content`` would treat that as a list of byte chunks.
-
 If the act of adding at detail is expensive, you might want to use
 addOnException_ so that you only do it when a test actually raises an
 exception.
 
=== modified file 'testtools/compat.py'
--- testtools/compat.py	2011-01-22 17:56:00 +0000
+++ testtools/compat.py	2011-02-01 18:58:11 +0000
@@ -2,24 +2,28 @@
 
 """Compatibility support for python 2 and 3."""
 
-
-import codecs
-import linecache
-import locale
-import os
-import re
-import sys
-import traceback
-
 __metaclass__ = type
 __all__ = [
     '_b',
     '_u',
     'advance_iterator',
     'str_is_unicode',
+    'StringIO',
     'unicode_output_stream',
     ]
 
+import codecs
+import linecache
+import locale
+import os
+import re
+import sys
+import traceback
+
+from testtools.helpers import try_imports
+
+StringIO = try_imports(['StringIO.StringIO', 'io.StringIO'])
+
 
 __u_doc = """A function version of the 'u' prefix.
 
 
=== modified file 'testtools/content.py'
--- testtools/content.py	2011-01-22 17:56:00 +0000
+++ testtools/content.py	2011-02-01 18:58:11 +0000
@@ -1,8 +1,18 @@
-# Copyright (c) 2009-2010 testtools developers. See LICENSE for details.
+# Copyright (c) 2009-2011 testtools developers. See LICENSE for details.
 
 """Content - a MIME-like Content object."""
 
+__all__ = [
+    'attach_file',
+    'Content',
+    'content_from_file',
+    'content_from_stream',
+    'text_content',
+    'TracebackContent',
+    ]
+
 import codecs
+import os
 
 from testtools.compat import _b
 from testtools.content_type import ContentType, UTF8_TEXT
@@ -12,6 +22,21 @@
 _join_b = _b("").join
 
 
+DEFAULT_CHUNK_SIZE = 4096
+
+
+def _iter_chunks(stream, chunk_size):
+    """Read 'stream' in chunks of 'chunk_size'.
+
+    :param stream: A file-like object to read from.
+    :param chunk_size: The size of each read from 'stream'.
+    """
+    chunk = stream.read(chunk_size)
+    while chunk:
+        yield chunk
+        chunk = stream.read(chunk_size)
+
+
 class Content(object):
     """A MIME-like Content object.
 
@@ -100,3 +125,92 @@
     This is useful for adding details which are short strings.
     """
     return Content(UTF8_TEXT, lambda: [text.encode('utf8')])
+
+
+def content_from_file(path, content_type=None, chunk_size=None,
+                      lazy_read=True):
+    """Create a `Content` object from a file on disk.
+
+    Note that unless 'read_now' is explicitly passed in as True, the file
+    will only be read from when ``iter_bytes`` is called.
+
+    :param path: The path to the file to be used as content.
+    :param content_type: The type of content.  If not specified, defaults
+        to UTF8-encoded text/plain.
+    :param chunk_size: The size of chunks to read from the file.
+        Defaults to `DEFAULT_CHUNK_SIZE`.
+    :param lazy_read: If False, read the file from disk now and keep it in
+        memory. Otherwise, only read when the content is serialized.
+    """
+    if content_type is None:
+        content_type = UTF8_TEXT
+    if chunk_size is None:
+        chunk_size = DEFAULT_CHUNK_SIZE
+    def reader():
+        stream = open(path, 'rb')
+        for chunk in _iter_chunks(stream, chunk_size):
+            yield chunk
+        stream.close()
+    if not lazy_read:
+        contents = list(reader())
+        reader = lambda: contents
+    return Content(content_type, reader)
+
+
+def content_from_stream(stream, content_type=None, chunk_size=None,
+                        lazy_read=True):
+    """Create a `Content` object from a file-like stream.
+
+    Note that the stream will only be read from when ``iter_bytes`` is
+    called.
+
+    :param stream: A file-like object to read the content from.
+    :param content_type: The type of content. If not specified, defaults
+        to UTF8-encoded text/plain.
+    :param chunk_size: The size of chunks to read from the file.
+        Defaults to `DEFAULT_CHUNK_SIZE`.
+    :param lazy_read: If False, reads from the stream right now. Otherwise,
+        only reads when the content is serialized. Defaults to True.
+    """
+    if content_type is None:
+        content_type = UTF8_TEXT
+    if chunk_size is None:
+        chunk_size = DEFAULT_CHUNK_SIZE
+    reader = lambda: _iter_chunks(stream, chunk_size)
+    if not lazy_read:
+        contents = list(reader())
+        reader = lambda: contents
+    return Content(content_type, reader)
+
+
+def attach_file(detailed, path, name=None, content_type=None,
+                chunk_size=None, lazy_read=False):
+    """Attach a file to this test as a detail.
+
+    This is a convenience method wrapping around `addDetail`.
+
+    Note that unless 'read_now' is explicitly passed in as True, the file
+    *must* exist when the test result is called with the results of this
+    test, after the test has been torn down.
+
+    :param detailed: An object with details
+    :param path: The path to the file to attach.
+    :param name: The name to give to the detail for the attached file.
+    :param content_type: The content type of the file.  If not provided,
+        defaults to UTF8-encoded text/plain.
+    :param chunk_size: The size of chunks to read from the file.  Defaults
+        to something sensible.
+    :param lazy_read: If True the file content is not read when attach_file is
+        called, but later when the content object is evaluated. Note that this
+        may be after any cleanups that obj_with_details has, so if the file is
+        a temporary file lazy_read may cause the file to be read after it is
+        deleted. To handle those cases, using attach_file as a cleanup is
+        recommended::
+
+            detailed.addCleanup(attach_file, 'foo.txt', detailed)
+    """
+    if name is None:
+        name = os.path.basename(os.path.abspath(path))
+    content_object = content_from_file(
+        path, content_type, chunk_size, lazy_read)
+    detailed.addDetail(name, content_object)
 
=== modified file 'testtools/deferredruntest.py'
--- testtools/deferredruntest.py	2011-01-22 17:56:00 +0000
+++ testtools/deferredruntest.py	2011-02-01 18:58:11 +0000
@@ -15,7 +15,7 @@
 
 import sys
 
-from testtools import try_imports
+from testtools.compat import StringIO
 from testtools.content import (
     Content,
     text_content,
@@ -34,8 +34,6 @@
 from twisted.python import log
 from twisted.trial.unittest import _LogObserver
 
-StringIO = try_imports(['StringIO.StringIO', 'io.StringIO'])
-
 
 class _DeferredRunTest(RunTest):
     """Base for tests that return Deferreds."""
 
=== modified file 'testtools/tests/test_content.py'
--- testtools/tests/test_content.py	2011-01-22 17:56:00 +0000
+++ testtools/tests/test_content.py	2011-02-01 18:58:11 +0000
@@ -1,11 +1,33 @@
-# Copyright (c) 2008-2010 testtools developers. See LICENSE for details.
+# Copyright (c) 2008-2011 testtools developers. See LICENSE for details.
 
+import os
+import tempfile
 import unittest
+
 from testtools import TestCase
-from testtools.compat import _b, _u
-from testtools.content import Content, TracebackContent, text_content
-from testtools.content_type import ContentType, UTF8_TEXT
-from testtools.matchers import MatchesException, Raises
+from testtools.compat import (
+    _b,
+    _u,
+    StringIO,
+    )
+from testtools.content import (
+    attach_file,
+    Content,
+    content_from_file,
+    content_from_stream,
+    TracebackContent,
+    text_content,
+    )
+from testtools.content_type import (
+    ContentType,
+    UTF8_TEXT,
+    )
+from testtools.matchers import (
+    Equals,
+    MatchesException,
+    Raises,
+    raises,
+    )
 from testtools.tests.helpers import an_exc_info
 
 
@@ -15,10 +37,11 @@
 class TestContent(TestCase):
 
     def test___init___None_errors(self):
-        self.assertThat(lambda:Content(None, None), raises_value_error)
-        self.assertThat(lambda:Content(None, lambda: ["traceback"]),
-            raises_value_error)
-        self.assertThat(lambda:Content(ContentType("text", "traceback"), None),
+        self.assertThat(lambda: Content(None, None), raises_value_error)
+        self.assertThat(
+            lambda: Content(None, lambda: ["traceback"]), raises_value_error)
+        self.assertThat(
+            lambda: Content(ContentType("text", "traceback"), None),
             raises_value_error)
 
     def test___init___sets_ivars(self):
@@ -64,12 +87,67 @@
         content = Content(content_type, lambda: [iso_version])
         self.assertEqual([text], list(content.iter_text()))
 
+    def test_from_file(self):
+        fd, path = tempfile.mkstemp()
+        self.addCleanup(os.remove, path)
+        os.write(fd, 'some data')
+        os.close(fd)
+        content = content_from_file(path, UTF8_TEXT, chunk_size=2)
+        self.assertThat(
+            list(content.iter_bytes()), Equals(['so', 'me', ' d', 'at', 'a']))
+
+    def test_from_nonexistent_file(self):
+        directory = tempfile.mkdtemp()
+        nonexistent = os.path.join(directory, 'nonexistent-file')
+        content = content_from_file(nonexistent)
+        self.assertThat(content.iter_bytes, raises(IOError))
+
+    def test_from_file_default_type(self):
+        content = content_from_file('/nonexistent/path')
+        self.assertThat(content.content_type, Equals(UTF8_TEXT))
+
+    def test_from_file_eager_loading(self):
+        fd, path = tempfile.mkstemp()
+        os.write(fd, 'some data')
+        os.close(fd)
+        content = content_from_file(path, UTF8_TEXT, lazy_read=False)
+        os.remove(path)
+        self.assertThat(
+            _b('').join(content.iter_bytes()), Equals('some data'))
+
+    def test_from_stream(self):
+        data = StringIO('some data')
+        content = content_from_stream(data, UTF8_TEXT, chunk_size=2)
+        self.assertThat(
+            list(content.iter_bytes()), Equals(['so', 'me', ' d', 'at', 'a']))
+
+    def test_from_stream_default_type(self):
+        data = StringIO('some data')
+        content = content_from_stream(data)
+        self.assertThat(content.content_type, Equals(UTF8_TEXT))
+
+    def test_from_stream_eager_loading(self):
+        fd, path = tempfile.mkstemp()
+        self.addCleanup(os.remove, path)
+        os.write(fd, 'some data')
+        stream = open(path, 'rb')
+        content = content_from_stream(stream, UTF8_TEXT, lazy_read=False)
+        os.write(fd, 'more data')
+        os.close(fd)
+        self.assertThat(
+            _b('').join(content.iter_bytes()), Equals('some data'))
+
+    def test_from_text(self):
+        data = _u("some data")
+        expected = Content(UTF8_TEXT, lambda: [data.encode('utf8')])
+        self.assertEqual(expected, text_content(data))
+
 
 class TestTracebackContent(TestCase):
 
     def test___init___None_errors(self):
-        self.assertThat(lambda:TracebackContent(None, None),
-            raises_value_error) 
+        self.assertThat(
+            lambda: TracebackContent(None, None), raises_value_error)
 
     def test___init___sets_ivars(self):
         content = TracebackContent(an_exc_info, self)
@@ -81,12 +159,63 @@
         self.assertEqual(expected, ''.join(list(content.iter_text())))
 
 
-class TestBytesContent(TestCase):
-
-    def test_bytes(self):
-        data = _u("some data")
-        expected = Content(UTF8_TEXT, lambda: [data.encode('utf8')])
-        self.assertEqual(expected, text_content(data))
+class TestAttachFile(TestCase):
+
+    def make_file(self, data):
+        fd, path = tempfile.mkstemp()
+        self.addCleanup(os.remove, path)
+        os.write(fd, data)
+        os.close(fd)
+        return path
+
+    def test_simple(self):
+        class SomeTest(TestCase):
+            def test_foo(self):
+                pass
+        test = SomeTest('test_foo')
+        data = 'some data'
+        path = self.make_file(data)
+        my_content = text_content(data)
+        attach_file(test, path, name='foo')
+        self.assertEqual({'foo': my_content}, test.getDetails())
+
+    def test_optional_name(self):
+        # If no name is provided, attach_file just uses the base name of the
+        # file.
+        class SomeTest(TestCase):
+            def test_foo(self):
+                pass
+        test = SomeTest('test_foo')
+        path = self.make_file('some data')
+        base_path = os.path.basename(path)
+        attach_file(test, path)
+        self.assertEqual([base_path], list(test.getDetails()))
+
+    def test_lazy_read(self):
+        class SomeTest(TestCase):
+            def test_foo(self):
+                pass
+        test = SomeTest('test_foo')
+        path = self.make_file('some data')
+        attach_file(test, path, name='foo', lazy_read=True)
+        content = test.getDetails()['foo']
+        content_file = open(path, 'w')
+        content_file.write('new data')
+        content_file.close()
+        self.assertEqual(''.join(content.iter_bytes()), 'new data')
+
+    def test_eager_read_by_default(self):
+        class SomeTest(TestCase):
+            def test_foo(self):
+                pass
+        test = SomeTest('test_foo')
+        path = self.make_file('some data')
+        attach_file(test, path, name='foo')
+        content = test.getDetails()['foo']
+        content_file = open(path, 'w')
+        content_file.write('new data')
+        content_file.close()
+        self.assertEqual(''.join(content.iter_bytes()), 'some data')
 
 
 def test_suite():
 
=== modified file 'testtools/tests/test_run.py'
--- testtools/tests/test_run.py	2011-01-22 17:56:00 +0000
+++ testtools/tests/test_run.py	2011-02-01 18:58:11 +0000
@@ -2,9 +2,9 @@
 
 """Tests for the test runner logic."""
 
-from testtools.helpers import try_import, try_imports
+from testtools.compat import StringIO
+from testtools.helpers import try_import
 fixtures = try_import('fixtures')
-StringIO = try_imports(['StringIO.StringIO', 'io.StringIO'])
 
 import testtools
 from testtools import TestCase, run
@@ -41,7 +41,7 @@
     def test_run_list(self):
         if fixtures is None:
             self.skipTest("Need fixtures")
-        package = self.useFixture(SampleTestFixture())
+        self.useFixture(SampleTestFixture())
         out = StringIO()
         run.main(['prog', '-l', 'testtools.runexample.test_suite'], out)
         self.assertEqual("""testtools.runexample.TestFoo.test_bar
@@ -51,7 +51,7 @@
     def test_run_load_list(self):
         if fixtures is None:
             self.skipTest("Need fixtures")
-        package = self.useFixture(SampleTestFixture())
+        self.useFixture(SampleTestFixture())
         out = StringIO()
         # We load two tests - one that exists and one that doesn't, and we
         # should get the one that exists and neither the one that doesn't nor
@@ -71,6 +71,7 @@
         self.assertEqual("""testtools.runexample.TestFoo.test_bar
 """, out.getvalue())
 
+
 def test_suite():
     from unittest import TestLoader
     return TestLoader().loadTestsFromName(__name__)
 
=== modified file 'testtools/tests/test_testresult.py'
--- testtools/tests/test_testresult.py	2011-01-22 17:56:00 +0000
+++ testtools/tests/test_testresult.py	2011-02-01 18:58:11 +0000
@@ -22,7 +22,6 @@
     TextTestResult,
     ThreadsafeForwardingResult,
     testresult,
-    try_imports,
     )
 from testtools.compat import (
     _b,
@@ -30,6 +29,7 @@
     _r,
     _u,
     str_is_unicode,
+    StringIO,
     )
 from testtools.content import Content
 from testtools.content_type import ContentType, UTF8_TEXT
@@ -47,8 +47,6 @@
     )
 from testtools.testresult.real import utc
 
-StringIO = try_imports(['StringIO.StringIO', 'io.StringIO'])
-
 
 class Python26Contract(object):
 
 
=== modified file 'testtools/tests/test_testtools.py'
--- testtools/tests/test_testtools.py	2011-01-22 17:56:00 +0000
+++ testtools/tests/test_testtools.py	2011-02-01 18:58:11 +0000
@@ -3,7 +3,9 @@
 """Tests for extensions to the base test library."""
 
 from pprint import pformat
+import os
 import sys
+import tempfile
 import unittest
 
 from testtools import (