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 6599a2b..a56bc6e 100755 (executable)
--- a/test/resources/planetlab/node.py
+++ b/test/resources/planetlab/node.py
@@ -4,9 +4,8 @@
 #    Copyright (C) 2013 INRIA
 #
 #    This program is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 3 of the License, or
-#    (at your option) any later version.
+#    it under the terms of the GNU General Public License version 2 as
+#    published by the Free Software Foundation;
 #
 #    This program is distributed in the hope that it will be useful,
 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -38,7 +37,7 @@ def create_node(ec, username, pl_user=None, pl_password=None, pl_url=None,
                 minBandwidth=None, minCpu=None,
                 architecture=None, city=None, ip=None):
 
-    node = ec.register_resource("PlanetlabNode")
+    node = ec.register_resource("planetlab::Node")
 
     if username:
         ec.set(node, "username", username)
@@ -66,7 +65,7 @@ def create_node(ec, username, pl_user=None, pl_password=None, pl_url=None,
     if ip:
         ec.set(node, "ip", ip)
 
-    ec.set(node, "cleanHome", True)
+    ec.set(node, "cleanExperiment", True)
     ec.set(node, "cleanProcesses", True)
     
     return node
@@ -74,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, "PlanetlabNode")
-        self.assertEquals(len(PlanetlabNode._attributes), 32)
+        self.assertEqual(PlanetlabNode._rtype, "planetlab::Node")
+        self.assertEqual(len(PlanetlabNode._attributes), 32)
 
 class PLNodeTestCase(unittest.TestCase):
     """
@@ -116,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, 
@@ -125,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)
@@ -162,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)        
@@ -201,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):
@@ -217,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):
@@ -251,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
@@ -263,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):
@@ -275,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):
@@ -296,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()