NBFormatTest is now a mixin, rather than a base class

IPython/nbformat/v3/tests/formattest.py

@@ -1,64 +1,63 b''
 # -*- coding: utf8 -*-
 import io
 import os
 import shutil
 import tempfile
 
 pjoin = os.path.join
 
-from unittest import TestCase
-
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook
 )
 
 from ..nbpy import reads, writes, read, write
 from .nbexamples import nb0, nb0_py
 
 
 def open_utf8(fname, mode):
     return io.open(fname, mode=mode, encoding='utf-8')
 
-class NBFormatTestCase(TestCase):
+class NBFormatTest:
+    """Mixin for writing notebook format tests"""
 
     # override with appropriate values in subclasses
     nb0_ref = None
     ext = None
     mod = None
     
     def setUp(self):
         self.wd = tempfile.mkdtemp()
     
     def tearDown(self):
         shutil.rmtree(self.wd)
     
     def assertNBEquals(self, nba, nbb):
         self.assertEquals(nba, nbb)
         
     def test_writes(self):
         s = self.mod.writes(nb0)
         if self.nb0_ref:
             self.assertEquals(s, self.nb0_ref)
 
     def test_reads(self):
         s = self.mod.writes(nb0)
         nb = self.mod.reads(s)
 
     def test_roundtrip(self):
         s = self.mod.writes(nb0)
         self.assertNBEquals(self.mod.reads(s),nb0)
 
     def test_write_file(self):
         with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'w') as f:
             self.mod.write(nb0, f)
     
     def test_read_file(self):
         with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'w') as f:
             self.mod.write(nb0, f)
         
         with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'r') as f:
             nb = self.mod.read(f)
         
 
         

IPython/nbformat/v3/tests/test_json.py

@@ -1,33 +1,33 b''
 import pprint
 from unittest import TestCase
 
 from ..nbjson import reads, writes
 from .. import nbjson
 from .nbexamples import nb0
 
 from . import formattest
 
 from .nbexamples import nb0
 
 
-class TestJSON(formattest.NBFormatTestCase):
+class TestJSON(formattest.NBFormatTest, TestCase):
 
     nb0_ref = None
     ext = 'ipynb'
     mod = nbjson
 
     def test_roundtrip_nosplit(self):
         """Ensure that multiline blobs are still readable"""
         # ensures that notebooks written prior to splitlines change
         # are still readable.
         s = writes(nb0, split_lines=False)
         self.assertEquals(nbjson.reads(s),nb0)
 
     def test_roundtrip_split(self):
         """Ensure that splitting multiline blocks is safe"""
         # This won't differ from test_roundtrip unless the default changes
         s = writes(nb0, split_lines=True)
         self.assertEquals(nbjson.reads(s),nb0)
 
 
 

IPython/nbformat/v3/tests/test_nbpy.py

@@ -1,43 +1,46 b''
 # -*- coding: utf8 -*-
+
+from unittest import TestCase
+
 from . import formattest
 
 from .. import nbpy
 from .nbexamples import nb0, nb0_py
 
 
-class TestPy(formattest.NBFormatTestCase):
+class TestPy(formattest.NBFormatTest, TestCase):
 
     nb0_ref = nb0_py
     ext = 'py'
     mod = nbpy
     ignored_keys = ['collapsed', 'outputs', 'prompt_number', 'metadata']
 
     def assertSubset(self, da, db):
         """assert that da is a subset of db, ignoring self.ignored_keys.
         
         Called recursively on containers, ultimately comparing individual
         elements.
         """
         if isinstance(da, dict):
             for k,v in da.iteritems():
                 if k in self.ignored_keys:
                     continue
                 self.assertTrue(k in db)
                 self.assertSubset(v, db[k])
         elif isinstance(da, list):
             for a,b in zip(da, db):
                 self.assertSubset(a,b)
         else:
             if isinstance(da, basestring) and isinstance(db, basestring):
                 # pyfile is not sensitive to preserving leading/trailing
                 # newlines in blocks through roundtrip
                 da = da.strip('\n')
                 db = db.strip('\n')
             self.assertEquals(da, db)
         return True
     
     def assertNBEquals(self, nba, nbb):
         # since roundtrip is lossy, only compare keys that are preserved
         # assumes nba is read from my file format
         return self.assertSubset(nba, nbb)