Python 3 support: switched assertEquals() to assertEqual().

The assertEquals() function is deperecated in Python 3.2:

  http://docs.python.org/py3k/library/unittest.html#deprecated-aliases

pystache/tests/common.py

@@ -55,10 +55,10 @@ class AssertStringMixin:
             description = details % reason
             return format % description
 
-        self.assertEquals(actual, expected, make_message("different characters"))
+        self.assertEqual(actual, expected, make_message("different characters"))
 
         reason = "types different: %s != %s (actual)" % (repr(type(expected)), repr(type(actual)))
-        self.assertEquals(type(expected), type(actual), make_message(reason))
+        self.assertEqual(type(expected), type(actual), make_message(reason))
 
 
 class AssertIsMixin:

pystache/tests/test_commands.py

@@ -39,7 +39,7 @@ class CommandsTestCase(unittest.TestCase):
 
         """
         actual = self.callScript("Hi {{thing}}", '{"thing": "world"}')
-        self.assertEquals(actual, u"Hi world\n")
+        self.assertEqual(actual, u"Hi world\n")
 
     def tearDown(self):
         sys.stdout = ORIGINAL_STDOUT

pystache/tests/test_examples.py

@@ -95,7 +95,7 @@ Again, Welcome!""")
         view.template = '''{{>partial_in_partial}}'''
 
         actual = renderer.render(view, {'prop': 'derp'})
-        self.assertEquals(actual, 'Hi derp!')
+        self.assertEqual(actual, 'Hi derp!')
 
 if __name__ == '__main__':
     unittest.main()

pystache/tests/test_loader.py

@@ -18,30 +18,30 @@ class LoaderTests(unittest.TestCase, AssertStringMixin):
 
     def test_init__extension(self):
         loader = Loader(extension='foo')
-        self.assertEquals(loader.extension, 'foo')
+        self.assertEqual(loader.extension, 'foo')
 
     def test_init__extension__default(self):
         # Test the default value.
         loader = Loader()
-        self.assertEquals(loader.extension, 'mustache')
+        self.assertEqual(loader.extension, 'mustache')
 
     def test_init__file_encoding(self):
         loader = Loader(file_encoding='bar')
-        self.assertEquals(loader.file_encoding, 'bar')
+        self.assertEqual(loader.file_encoding, 'bar')
 
     def test_init__file_encoding__default(self):
         file_encoding = defaults.FILE_ENCODING
         try:
             defaults.FILE_ENCODING = 'foo'
             loader = Loader()
-            self.assertEquals(loader.file_encoding, 'foo')
+            self.assertEqual(loader.file_encoding, 'foo')
         finally:
             defaults.FILE_ENCODING = file_encoding
 
     def test_init__to_unicode(self):
         to_unicode = lambda x: x
         loader = Loader(to_unicode=to_unicode)
-        self.assertEquals(loader.to_unicode, to_unicode)
+        self.assertEqual(loader.to_unicode, to_unicode)
 
     def test_init__to_unicode__default(self):
         loader = Loader()

pystache/tests/test_locator.py

@@ -26,10 +26,10 @@ class LocatorTests(unittest.TestCase):
     def test_init__extension(self):
         # Test the default value.
         locator = Locator()
-        self.assertEquals(locator.template_extension, 'mustache')
+        self.assertEqual(locator.template_extension, 'mustache')
 
         locator = Locator(extension='txt')
-        self.assertEquals(locator.template_extension, 'txt')
+        self.assertEqual(locator.template_extension, 'txt')
 
         locator = Locator(extension=False)
         self.assertTrue(locator.template_extension is False)
@@ -40,40 +40,40 @@ class LocatorTests(unittest.TestCase):
         obj = SayHello()
         actual = locator.get_object_directory(obj)
 
-        self.assertEquals(actual, os.path.abspath(DATA_DIR))
+        self.assertEqual(actual, os.path.abspath(DATA_DIR))
 
     def test_get_object_directory__not_hasattr_module(self):
         locator = Locator()
 
         obj = datetime(2000, 1, 1)
         self.assertFalse(hasattr(obj, '__module__'))
-        self.assertEquals(locator.get_object_directory(obj), None)
+        self.assertEqual(locator.get_object_directory(obj), None)
 
         self.assertFalse(hasattr(None, '__module__'))
-        self.assertEquals(locator.get_object_directory(None), None)
+        self.assertEqual(locator.get_object_directory(None), None)
 
     def test_make_file_name(self):
         locator = Locator()
 
         locator.template_extension = 'bar'
-        self.assertEquals(locator.make_file_name('foo'), 'foo.bar')
+        self.assertEqual(locator.make_file_name('foo'), 'foo.bar')
 
         locator.template_extension = False
-        self.assertEquals(locator.make_file_name('foo'), 'foo')
+        self.assertEqual(locator.make_file_name('foo'), 'foo')
 
         locator.template_extension = ''
-        self.assertEquals(locator.make_file_name('foo'), 'foo.')
+        self.assertEqual(locator.make_file_name('foo'), 'foo.')
 
     def test_make_file_name__template_extension_argument(self):
         locator = Locator()
 
-        self.assertEquals(locator.make_file_name('foo', template_extension='bar'), 'foo.bar')
+        self.assertEqual(locator.make_file_name('foo', template_extension='bar'), 'foo.bar')
 
     def test_find_name(self):
         locator = Locator()
         path = locator.find_name(search_dirs=['examples'], template_name='simple')
 
-        self.assertEquals(os.path.basename(path), 'simple.mustache')
+        self.assertEqual(os.path.basename(path), 'simple.mustache')
 
     def test_find_name__using_list_of_paths(self):
         locator = Locator()
@@ -98,7 +98,7 @@ class LocatorTests(unittest.TestCase):
         dirpath = os.path.dirname(path)
         dirname = os.path.split(dirpath)[-1]
 
-        self.assertEquals(dirname, 'locator')
+        self.assertEqual(dirname, 'locator')
 
     def test_find_name__non_existent_template_fails(self):
         locator = Locator()
@@ -113,7 +113,7 @@ class LocatorTests(unittest.TestCase):
         actual = locator.find_object(search_dirs=[], obj=obj, file_name='sample_view.mustache')
         expected = os.path.abspath(os.path.join(DATA_DIR, 'sample_view.mustache'))
 
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
     def test_find_object__none_file_name(self):
         locator = Locator()
@@ -123,18 +123,18 @@ class LocatorTests(unittest.TestCase):
         actual = locator.find_object(search_dirs=[], obj=obj)
         expected = os.path.abspath(os.path.join(DATA_DIR, 'say_hello.mustache'))
 
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
     def test_find_object__none_object_directory(self):
         locator = Locator()
 
         obj = None
-        self.assertEquals(None, locator.get_object_directory(obj))
+        self.assertEqual(None, locator.get_object_directory(obj))
 
         actual = locator.find_object(search_dirs=[DATA_DIR], obj=obj, file_name='say_hello.mustache')
         expected = os.path.join(DATA_DIR, 'say_hello.mustache')
 
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
     def test_make_template_name(self):
         """
@@ -147,4 +147,4 @@ class LocatorTests(unittest.TestCase):
             pass
         foo = FooBar()
 
-        self.assertEquals(locator.make_template_name(foo), 'foo_bar')
+        self.assertEqual(locator.make_template_name(foo), 'foo_bar')

pystache/tests/test_pystache.py

@@ -9,15 +9,15 @@ class PystacheTests(unittest.TestCase):
 
     def _assert_rendered(self, expected, template, context):
         actual = pystache.render(template, context)
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
     def test_basic(self):
         ret = pystache.render("Hi {{thing}}!", { 'thing': 'world' })
-        self.assertEquals(ret, "Hi world!")
+        self.assertEqual(ret, "Hi world!")
 
     def test_kwargs(self):
         ret = pystache.render("Hi {{thing}}!", thing='world')
-        self.assertEquals(ret, "Hi world!")
+        self.assertEqual(ret, "Hi world!")
 
     def test_less_basic(self):
         template = "It's a nice day for {{beverage}}, right {{person}}?"
@@ -42,7 +42,7 @@ class PystacheTests(unittest.TestCase):
     def test_comments(self):
         template = "What {{! the }} what?"
         actual = pystache.render(template)
-        self.assertEquals("What  what?", actual)
+        self.assertEqual("What  what?", actual)
 
     def test_false_sections_are_hidden(self):
         template = "Ready {{#set}}set {{/set}}go!"

pystache/tests/test_renderengine.py

@@ -26,9 +26,9 @@ class RenderEngineTestCase(unittest.TestCase):
         # In real-life, these arguments would be functions
         engine = RenderEngine(load_partial="foo", literal="literal", escape="escape")
 
-        self.assertEquals(engine.escape, "escape")
-        self.assertEquals(engine.literal, "literal")
-        self.assertEquals(engine.load_partial, "foo")
+        self.assertEqual(engine.escape, "escape")
+        self.assertEqual(engine.literal, "literal")
+        self.assertEqual(engine.load_partial, "foo")
 
 
 class RenderTests(unittest.TestCase, AssertStringMixin):
@@ -315,7 +315,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin):
         try:
             self._assert_render(None, template)
         except ParsingError, err:
-            self.assertEquals(str(err), "Section end tag mismatch: u'section' != None")
+            self.assertEqual(str(err), "Section end tag mismatch: u'section' != None")
 
     def test_section__end_tag_mismatch(self):
         """
@@ -326,7 +326,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin):
         try:
             self._assert_render(None, template)
         except ParsingError, err:
-            self.assertEquals(str(err), "Section end tag mismatch: u'section_end' != u'section_start'")
+            self.assertEqual(str(err), "Section end tag mismatch: u'section_end' != u'section_start'")
 
     def test_section__context_values(self):
         """

pystache/tests/test_simple.py

@@ -28,11 +28,11 @@ class TestSimple(unittest.TestCase, AssertStringMixin):
 
         renderer = Renderer()
         actual = renderer.render(template, context)
-        self.assertEquals(actual, "Colors: red Colors: green Colors: blue ")
+        self.assertEqual(actual, "Colors: red Colors: green Colors: blue ")
 
     def test_empty_context(self):
         template = '{{#empty_list}}Shouldnt see me {{/empty_list}}{{^empty_list}}Should see me{{/empty_list}}'
-        self.assertEquals(pystache.Renderer().render(template), "Should see me")
+        self.assertEqual(pystache.Renderer().render(template), "Should see me")
 
     def test_callables(self):
         view = Lambdas()
@@ -58,7 +58,7 @@ class TestSimple(unittest.TestCase, AssertStringMixin):
     def test_non_existent_value_renders_blank(self):
         view = Simple()
         template = '{{not_set}} {{blank}}'
-        self.assertEquals(pystache.Renderer().render(template), ' ')
+        self.assertEqual(pystache.Renderer().render(template), ' ')
 
 
     def test_template_partial_extension(self):

pystache/tests/test_template_spec.py

@@ -49,7 +49,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
         # TODO: change this test to remove the following brittle line.
         view.template_rel_directory = "../../examples"
         actual = renderer.render(view)
-        self.assertEquals(actual, "No tags...")
+        self.assertEqual(actual, "No tags...")
 
     def test_template_path_for_partials(self):
         """
@@ -65,7 +65,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
         self.assertRaises(IOError, renderer1.render, spec)
 
         actual = renderer2.render(spec)
-        self.assertEquals(actual, "Partial: No tags...")
+        self.assertEqual(actual, "Partial: No tags...")
 
     def test_basic_method_calls(self):
         renderer = Renderer()
@@ -79,7 +79,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
 
         renderer = Renderer()
         actual = renderer.render(view)
-        self.assertEquals(actual, "Hi Chris!")
+        self.assertEqual(actual, "Hi Chris!")
 
     def test_complex(self):
         renderer = Renderer()
@@ -95,7 +95,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
     def test_higher_order_replace(self):
         renderer = Renderer()
         actual = renderer.render(Lambdas())
-        self.assertEquals(actual, 'bar != bar. oh, it does!')
+        self.assertEqual(actual, 'bar != bar. oh, it does!')
 
     def test_higher_order_rot13(self):
         view = Lambdas()
@@ -119,7 +119,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
 
         renderer = Renderer(search_dirs=EXAMPLES_DIR)
         actual = renderer.render(view)
-        self.assertEquals(actual, u'nopqrstuvwxyz')
+        self.assertEqual(actual, u'nopqrstuvwxyz')
 
     def test_hierarchical_partials_with_lambdas(self):
         view = Lambdas()
@@ -164,8 +164,8 @@ class SpecLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin):
 
         # Check the loader attribute.
         loader = custom.loader
-        self.assertEquals(loader.extension, 'mustache')
-        self.assertEquals(loader.file_encoding, sys.getdefaultencoding())
+        self.assertEqual(loader.extension, 'mustache')
+        self.assertEqual(loader.file_encoding, sys.getdefaultencoding())
         # TODO: finish testing the other Loader attributes.
         to_unicode = loader.to_unicode
 
@@ -255,8 +255,8 @@ class SpecLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin):
 
         # Check that our unicode() above was called.
         self._assert_template(custom_loader, view, u'foo')
-        self.assertEquals(loader.s, "template-foo")
-        self.assertEquals(loader.encoding, "encoding-foo")
+        self.assertEqual(loader.s, "template-foo")
+        self.assertEqual(loader.encoding, "encoding-foo")
 
 
 # TODO: migrate these tests into the SpecLoaderTests class.
@@ -273,7 +273,7 @@ class TemplateSpecTests(unittest.TestCase):
     def _assert_template_location(self, view, expected):
         locator = self._make_locator()
         actual = locator._find_relative(view)
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
     def test_find_relative(self):
         """
@@ -343,7 +343,7 @@ class TemplateSpecTests(unittest.TestCase):
         actual = locator._find(view)
         expected = os.path.abspath(os.path.join(DATA_DIR, 'foo/bar.txt'))
 
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
     def test_find__without_directory(self):
         """
@@ -358,14 +358,14 @@ class TemplateSpecTests(unittest.TestCase):
         actual = locator._find(view)
         expected = os.path.abspath(os.path.join(DATA_DIR, 'sample_view.mustache'))
 
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
     def _assert_get_template(self, custom, expected):
         locator = self._make_locator()
         actual = locator.load(custom)
 
-        self.assertEquals(type(actual), unicode)
-        self.assertEquals(actual, expected)
+        self.assertEqual(type(actual), unicode)
+        self.assertEqual(actual, expected)
 
     def test_get_template(self):
         """