replacing assertEquals into assertEqual

[nepi.git] / test / resources / planetlab / node.py

diff --git a/test/resources/planetlab/node.py b/test/resources/planetlab/node.py
index 5714645..a56bc6e 100755 (executable)
--- a/test/resources/planetlab/node.py
+++ b/test/resources/planetlab/node.py
@@ -73,8 +73,8 @@ def create_node(ec, username, pl_user=None, pl_password=None, pl_url=None,
 class PLNodeFactoryTestCase(unittest.TestCase):
 
     def test_creation_phase(self):
-        self.assertEquals(PlanetlabNode._rtype, "planetlab::Node")
-        self.assertEquals(len(PlanetlabNode._attributes), 32)
+        self.assertEqual(PlanetlabNode._rtype, "planetlab::Node")
+        self.assertEqual(len(PlanetlabNode._attributes), 32)
 
 class PLNodeTestCase(unittest.TestCase):
     """
@@ -115,8 +115,8 @@ class PLNodeTestCase(unittest.TestCase):
 
         api1 = plnode_rm1.plapi
         self.assertIsInstance(api1, PLCAPI)
-        self.assertEquals(len(api1.reserved()), 0)
-        self.assertEquals(len(api1.blacklisted()), 0)
+        self.assertEqual(len(api1.reserved()), 0)
+        self.assertEqual(len(api1.blacklisted()), 0)
 
         node2 = create_node(self.ec, self.username, pl_user=self.pl_user,   
             pl_password=self.pl_password, pl_url=self.pl_url, 
@@ -124,7 +124,7 @@ class PLNodeTestCase(unittest.TestCase):
         
         plnode_rm2 = self.ec.get_resource(node2)
         api2 = plnode_rm2.plapi
-        self.assertEquals(api1, api2)
+        self.assertEqual(api1, api2)
     
         # Set hostname attribute in order for the shutdown method not to fail
         plnode_rm1._set_hostname_attr(3)
@@ -161,7 +161,7 @@ class PLNodeTestCase(unittest.TestCase):
         self.assertIsNone(hostname)
 
         plnode_rm.do_discover()
-        self.assertEquals(plnode_rm._node_to_provision, 3)
+        self.assertEqual(plnode_rm._node_to_provision, 3)
 
        # Set hostname attribute in order for the shutdown method not to fail
         plnode_rm._set_hostname_attr(plnode_rm._node_to_provision)        
@@ -200,8 +200,8 @@ class PLNodeTestCase(unittest.TestCase):
         plnode_rm = self.ec.get_resource(node)
         plnode_rm.do_discover()
 
-        self.assertEquals(plnode_rm._node_to_provision, 3)
-        self.assertEquals(plnode_rm.plapi.reserved(), set([3]))
+        self.assertEqual(plnode_rm._node_to_provision, 3)
+        self.assertEqual(plnode_rm.plapi.reserved(), set([3]))
 
     @skipIfNotPLCredentials
     def test_discover_ip(self):
@@ -216,9 +216,9 @@ class PLNodeTestCase(unittest.TestCase):
         plnode_rm = self.ec.get_resource(node)
         plnode_rm.do_discover()
 
-        self.assertEquals(plnode_rm._node_to_provision, 3)
-        self.assertEquals(plnode_rm.plapi.reserved(), set([3]))
-        self.assertEquals(plnode_rm.get("hostname"), "nepi2.pl.sophia.inria.fr")
+        self.assertEqual(plnode_rm._node_to_provision, 3)
+        self.assertEqual(plnode_rm.plapi.reserved(), set([3]))
+        self.assertEqual(plnode_rm.get("hostname"), "nepi2.pl.sophia.inria.fr")
 
     @skipIfNotPLCredentials
     def test_discover_with_ranges(self):
@@ -250,7 +250,7 @@ class PLNodeTestCase(unittest.TestCase):
                 hostname="nepi1.pl.sophia.inria.fr")
 
         plnode_rm = self.ec.get_resource(node)
-        self.assertEquals(plnode_rm.plapi.blacklisted(), set())
+        self.assertEqual(plnode_rm.plapi.blacklisted(), set())
 
         # check that the node is actually malfunctioning
         api = plnode_rm.plapi
@@ -262,7 +262,7 @@ class PLNodeTestCase(unittest.TestCase):
         if not node_id:
             with self.assertRaises(RuntimeError):
                 plnode_rm.do_discover()
-                self.assertEquals(plnode_rm.plapi.blacklisted(), set([1]))
+                self.assertEqual(plnode_rm.plapi.blacklisted(), set([1]))
 
     @skipIfNotPLCredentials
     def test_provision_node_inslice(self):
@@ -274,14 +274,14 @@ class PLNodeTestCase(unittest.TestCase):
             architecture="x86_64", operatingSystem="f12")
 
         plnode_rm = self.ec.get_resource(node)
-        self.assertEquals(len(plnode_rm.plapi.blacklisted()), 0)
-        self.assertEquals(len(plnode_rm.plapi.reserved()), 0)
+        self.assertEqual(len(plnode_rm.plapi.blacklisted()), 0)
+        self.assertEqual(len(plnode_rm.plapi.reserved()), 0)
 
         plnode_rm.do_discover()
         plnode_rm.do_provision()
         ip = plnode_rm.get("ip")
-        self.assertEquals(ip, "138.96.116.32")
-        self.assertEquals(len(plnode_rm.plapi.reserved()), 1)
+        self.assertEqual(ip, "138.96.116.32")
+        self.assertEqual(len(plnode_rm.plapi.reserved()), 1)
 
     @skipIfNotPLCredentials
     def test_provision_node_not_inslice(self):
@@ -295,8 +295,8 @@ class PLNodeTestCase(unittest.TestCase):
             city='Paris')
 
         plnode_rm = self.ec.get_resource(node)
-        self.assertEquals(plnode_rm.plapi.blacklisted(), set())
-        self.assertEquals(plnode_rm.plapi.reserved(), set())
+        self.assertEqual(plnode_rm.plapi.blacklisted(), set())
+        self.assertEqual(plnode_rm.plapi.reserved(), set())
 
         plnode_rm.do_discover()
         plnode_rm.do_provision()