time.sleep(1)
- self.assertEquals('hola!', task.result)
+ self.assertEqual('hola!', task.result)
ec.shutdown()
time.sleep(1)
- self.assertEquals(task.status, TaskStatus.ERROR)
+ self.assertEqual(task.status, TaskStatus.ERROR)
if __name__ == '__main__':
unittest.main()
ResourceFactory.register_type(AnotherResource)
# Take into account default 'Critical' attribute
- self.assertEquals(MyResource.get_rtype(), "MyResource")
- self.assertEquals(len(MyResource._attributes), 3)
+ self.assertEqual(MyResource.get_rtype(), "MyResource")
+ self.assertEqual(len(MyResource._attributes), 3)
- self.assertEquals(ResourceManager.get_rtype(), "Resource")
- self.assertEquals(len(ResourceManager._attributes), 2)
+ self.assertEqual(ResourceManager.get_rtype(), "Resource")
+ self.assertEqual(len(ResourceManager._attributes), 2)
- self.assertEquals(AnotherResource.get_rtype(), "AnotherResource")
- self.assertEquals(len(AnotherResource._attributes), 2)
+ self.assertEqual(AnotherResource.get_rtype(), "AnotherResource")
+ self.assertEqual(len(AnotherResource._attributes), 2)
- self.assertEquals(len(ResourceFactory.resource_types()), 2)
+ self.assertEqual(len(ResourceFactory.resource_types()), 2)
# restore factory state for other tests
from nepi.execution.resource import populate_factory
for (group, state, time) in conditions:
waiting_for.extend(group)
- self.assertEquals(waiting_for, [1, 3, 5, 7, 10, 8])
+ self.assertEqual(waiting_for, [1, 3, 5, 7, 10, 8])
group = [1, 2, 3, 4, 6]
rm.unregister_condition(group)
for (group, state, time) in conditions:
waiting_for.extend(group)
- self.assertEquals(waiting_for, [5, 7, 10, 8])
+ self.assertEqual(waiting_for, [5, 7, 10, 8])
def test_deploy_in_order(self):
"""
ec.shutdown()
- self.assertEquals(ec._fm._failure_level, FailureLevel.RM_FAILURE)
+ self.assertEqual(ec._fm._failure_level, FailureLevel.RM_FAILURE)
def test_critical(self):
from nepi.execution.resource import ResourceFactory
ec.wait_finished(apps)
state = ec.state(eapp)
- self.assertEquals(state, ResourceState.FAILED)
+ self.assertEqual(state, ResourceState.FAILED)
apps.remove(eapp)
for app in apps:
state = ec.state(app)
- self.assertEquals(state, ResourceState.STOPPED)
+ self.assertEqual(state, ResourceState.STOPPED)
ec.shutdown()
- self.assertEquals(ec._fm._failure_level, FailureLevel.OK)
+ self.assertEqual(ec._fm._failure_level, FailureLevel.OK)
def test_start_with_condition(self):
from nepi.execution.resource import ResourceFactory
runs = rnr.run(ec, min_runs = 5, max_runs = 10, wait_guids = apps,
wait_time = 0)
- self.assertEquals(runs, 10)
+ self.assertEqual(runs, 10)
def test_runner_convergence(self):
node_count = 4
wait_guids = apps,
wait_time = 0)
- self.assertEquals(runs, 10)
+ self.assertEqual(runs, 10)
if __name__ == '__main__':
unittest.main()
# Make sure tasks are retrieved in teh correct order
tsk = scheduler.next()
- self.assertEquals(tsk.callback(), 1)
+ self.assertEqual(tsk.callback(), 1)
tsk = scheduler.next()
- self.assertEquals(tsk.callback(), 2)
+ self.assertEqual(tsk.callback(), 2)
tsk = scheduler.next()
- self.assertEquals(tsk.callback(), 3)
+ self.assertEqual(tsk.callback(), 3)
if __name__ == '__main__':
stdout = ec.trace(app, "stdout")
size = ec.trace(app, "stdout", attr = TraceAttr.SIZE)
- self.assertEquals(len(stdout), size)
+ self.assertEqual(len(stdout), size)
block = ec.trace(app, "stdout", attr = TraceAttr.STREAM, block = 5, offset = 1)
- self.assertEquals(block, stdout[5:10])
+ self.assertEqual(block, stdout[5:10])
path = ec.trace(app, "stdout", attr = TraceAttr.PATH)
rm = ec.get_resource(app)
p = os.path.join(rm.run_home, "stdout")
- self.assertEquals(path, p)
+ self.assertEqual(path, p)
ec.shutdown()
ec.wait_finished(app)
out = ec.trace(app, 'stdout')
- self.assertEquals(out, "Hello, world!\n")
+ self.assertEqual(out, "Hello, world!\n")
ec.shutdown()
for app in apps:
stdout = ec.trace(app, 'stdout')
size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
- self.assertEquals(len(stdout), size)
+ self.assertEqual(len(stdout), size)
block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
- self.assertEquals(block, stdout[5:10])
+ self.assertEqual(block, stdout[5:10])
path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
rm = ec.get_resource(app)
p = os.path.join(rm.run_home, 'stdout')
- self.assertEquals(path, p)
+ self.assertEqual(path, p)
ec.shutdown()
if os.path.isdir(path):
dircount += 1
logs = glob.glob(os.path.join(path, "*.stdout"))
- self.assertEquals(len(logs), 1)
+ self.assertEqual(len(logs), 1)
- self.assertEquals(runs, dircount)
+ self.assertEqual(runs, dircount)
shutil.rmtree(dirpath)
# get the pid of the process
ecode = node.exitcode(app_home)
- self.assertEquals(ecode, ExitCode.OK)
+ self.assertEqual(ecode, ExitCode.OK)
@skipIfNotAlive
def t_exitcode_kill(self, host, user):
# The process is still running, so no retfile has been created yet
ecode = node.exitcode(app_home)
- self.assertEquals(ecode, ExitCode.FILENOTFOUND)
+ self.assertEqual(ecode, ExitCode.FILENOTFOUND)
(out, err), proc = node.check_errors(app_home)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
# Now kill the app
pid, ppid = node.getpid(app_home)
node.kill(pid, ppid)
(out, err), proc = node.check_errors(app_home)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
@skipIfNotAlive
def t_exitcode_error(self, host, user):
ecode = node.exitcode(app_home)
# bash erro 127 - command not found
- self.assertEquals(ecode, 127)
+ self.assertEqual(ecode, 127)
(out, err), proc = node.check_errors(app_home)
node.find_home()
(out, err), proc = node.mkdir(node.node_home, clean = True)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
(out, err), proc = node.install_packages("gcc", node.node_home)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
(out, err), proc = node.remove_packages("gcc", node.node_home)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
(out, err), proc = node.rmdir(node.exp_home)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
@skipIfNotAlive
def t_clean(self, host, user):
command1 = " [ -d %s ] && echo 'Found'" % node.lib_dir
(out, err), proc = node.execute(command1)
- self.assertEquals(out.strip(), "Found")
+ self.assertEqual(out.strip(), "Found")
command2 = " [ -d %s ] && echo 'Found'" % node.node_home
(out, err), proc = node.execute(command2)
- self.assertEquals(out.strip(), "Found")
+ self.assertEqual(out.strip(), "Found")
node.clean_experiment()
(out, err), proc = node.execute(command2)
- self.assertEquals(out.strip(), "")
+ self.assertEqual(out.strip(), "")
node.clean_home()
(out, err), proc = node.execute(command1)
- self.assertEquals(out.strip(), "")
+ self.assertEqual(out.strip(), "")
@skipIfNotAlive
def t_xterm(self, host, user):
node.find_home()
(out, err), proc = node.mkdir(node.node_home, clean = True)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
node.install_packages("xterm", node.node_home)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
(out, err), proc = node.execute("xterm", forward_x11 = True)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
(out, err), proc = node.remove_packages("xterm", node.node_home)
- self.assertEquals(err, "")
+ self.assertEqual(err, "")
@skipIfNotAlive
def t_compile(self, host, user):
command = "%s/hello" % app_home
(out, err), proc = node.execute(command)
- self.assertEquals(out, "Hello, world!\n")
+ self.assertEqual(out, "Hello, world!\n")
# execute the program and get the output from a file
command = "%(home)s/hello > %(home)s/hello.out" % {
with open(dst, "r") as f:
out = f.read()
- self.assertEquals(out, "Hello, world!\n")
+ self.assertEqual(out, "Hello, world!\n")
@skipIfNotAlive
def t_copy_files(self, host, user):
output = ec.trace(guid, trace)
size = ec.trace(guid, trace, attr = TraceAttr.SIZE)
- self.assertEquals(size, len(output))
+ self.assertEqual(size, len(output))
self.assertTrue(size > 100)
block = ec.trace(guid, trace, attr = TraceAttr.STREAM, block = 5, offset = 1)
- self.assertEquals(block, output[5:10])
+ self.assertEqual(block, output[5:10])
trace_path = ec.trace(guid, trace, attr = TraceAttr.PATH)
rm = ec.get_resource(guid)
path = os.path.join(rm_simu.run_home, rm._trace_filename.get(trace))
- self.assertEquals(trace_path, path)
+ self.assertEqual(trace_path, path)
ec.shutdown()
ec2.wait_finished([ping])
- self.assertEquals(len(ec.resources), len(ec2.resources))
+ self.assertEqual(len(ec.resources), len(ec2.resources))
stdout = ec2.trace(simu, "stdout")
ec2.wait_finished([ping])
- self.assertEquals(len(ec.resources), len(ec2.resources))
+ self.assertEqual(len(ec.resources), len(ec2.resources))
stdout = ec2.trace(simu, "stdout")
# Give time to flush the streams
time.sleep(5)
- self.assertEquals(len(ec.resources), len(ec2.resources))
+ self.assertEqual(len(ec.resources), len(ec2.resources))
expected = "udp-perf --duration=10 --nodes=2"
cmdline = ec2.trace(udp_perf, "cmdline")
ec2.deploy()
ec2.wait_finished(apps)
- self.assertEquals(len(ec.resources), len(ec2.resources))
+ self.assertEqual(len(ec.resources), len(ec2.resources))
self.assertTrue(ec2.state(node) == ResourceState.STARTED)
self.assertTrue(ec2.state(server) == ResourceState.STOPPED)
stderr = subprocess.PIPE, shell = True)
(out, err) = p.communicate()
- self.assertEquals(int(out), 8)
+ self.assertEqual(int(out), 8)
p = subprocess.Popen("rm /tmp/csma-ping-*", shell = True)
p.communicate()
class OMFResourceFactoryTestCase(unittest.TestCase):
def test_creation_phase(self):
- self.assertEquals(OMFNode.get_rtype(), "omf::Node")
- self.assertEquals(len(OMFNode._attributes), 8)
+ self.assertEqual(OMFNode.get_rtype(), "omf::Node")
+ self.assertEqual(len(OMFNode._attributes), 8)
- self.assertEquals(OMFWifiInterface.get_rtype(), "omf::WifiInterface")
- self.assertEquals(len(OMFWifiInterface._attributes), 12)
+ self.assertEqual(OMFWifiInterface.get_rtype(), "omf::WifiInterface")
+ self.assertEqual(len(OMFWifiInterface._attributes), 12)
- self.assertEquals(OMFChannel.get_rtype(), "omf::Channel")
- self.assertEquals(len(OMFChannel._attributes), 8)
+ self.assertEqual(OMFChannel.get_rtype(), "omf::Channel")
+ self.assertEqual(len(OMFChannel._attributes), 8)
- self.assertEquals(OMFApplication.get_rtype(), "omf::Application")
- self.assertEquals(len(OMFApplication._attributes), 14)
+ self.assertEqual(OMFApplication.get_rtype(), "omf::Application")
+ self.assertEqual(len(OMFApplication._attributes), 14)
class OMFEachTestCase(unittest.TestCase):
def setUp(self):
self.ec.shutdown()
def test_creation_and_configuration_node(self):
- self.assertEquals(self.ec.get(self.node1, 'hostname'), 'omf.plexus.wlab17')
- self.assertEquals(self.ec.get(self.node1, 'xmppUser'), 'nepi')
- self.assertEquals(self.ec.get(self.node1, 'xmppServer'), 'xmpp-plexus.onelab.eu')
- self.assertEquals(self.ec.get(self.node1, 'xmppPort'), '5222')
- self.assertEquals(self.ec.get(self.node1, 'xmppPassword'), '1234')
- self.assertEquals(self.ec.get(self.node1, 'version'), '5')
+ self.assertEqual(self.ec.get(self.node1, 'hostname'), 'omf.plexus.wlab17')
+ self.assertEqual(self.ec.get(self.node1, 'xmppUser'), 'nepi')
+ self.assertEqual(self.ec.get(self.node1, 'xmppServer'), 'xmpp-plexus.onelab.eu')
+ self.assertEqual(self.ec.get(self.node1, 'xmppPort'), '5222')
+ self.assertEqual(self.ec.get(self.node1, 'xmppPassword'), '1234')
+ self.assertEqual(self.ec.get(self.node1, 'version'), '5')
def test_creation_and_configuration_interface(self):
- self.assertEquals(self.ec.get(self.iface1, 'name'), 'wlan0')
- self.assertEquals(self.ec.get(self.iface1, 'mode'), 'adhoc')
- self.assertEquals(self.ec.get(self.iface1, 'hw_mode'), 'g')
- self.assertEquals(self.ec.get(self.iface1, 'essid'), 'vlcexp')
- self.assertEquals(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
- self.assertEquals(self.ec.get(self.iface1, 'version'), '5')
+ self.assertEqual(self.ec.get(self.iface1, 'name'), 'wlan0')
+ self.assertEqual(self.ec.get(self.iface1, 'mode'), 'adhoc')
+ self.assertEqual(self.ec.get(self.iface1, 'hw_mode'), 'g')
+ self.assertEqual(self.ec.get(self.iface1, 'essid'), 'vlcexp')
+ self.assertEqual(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
+ self.assertEqual(self.ec.get(self.iface1, 'version'), '5')
def test_creation_and_configuration_channel(self):
- self.assertEquals(self.ec.get(self.channel, 'channel'), '6')
- self.assertEquals(self.ec.get(self.channel, 'xmppUser'), 'nepi')
- self.assertEquals(self.ec.get(self.channel, 'xmppServer'), 'xmpp-plexus.onelab.eu')
- self.assertEquals(self.ec.get(self.channel, 'xmppPort'), '5222')
- self.assertEquals(self.ec.get(self.channel, 'xmppPassword'), '1234')
- self.assertEquals(self.ec.get(self.channel, 'version'), '5')
+ self.assertEqual(self.ec.get(self.channel, 'channel'), '6')
+ self.assertEqual(self.ec.get(self.channel, 'xmppUser'), 'nepi')
+ self.assertEqual(self.ec.get(self.channel, 'xmppServer'), 'xmpp-plexus.onelab.eu')
+ self.assertEqual(self.ec.get(self.channel, 'xmppPort'), '5222')
+ self.assertEqual(self.ec.get(self.channel, 'xmppPassword'), '1234')
+ self.assertEqual(self.ec.get(self.channel, 'version'), '5')
def test_creation_and_configuration_application(self):
- self.assertEquals(self.ec.get(self.app1, 'appid'), 'Vlc#1')
- self.assertEquals(self.ec.get(self.app1, 'command'), "/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'")
- self.assertEquals(self.ec.get(self.app1, 'env'), 'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
- self.assertEquals(self.ec.get(self.app1, 'version'), '5')
+ self.assertEqual(self.ec.get(self.app1, 'appid'), 'Vlc#1')
+ self.assertEqual(self.ec.get(self.app1, 'command'), "/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'")
+ self.assertEqual(self.ec.get(self.app1, 'env'), 'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
+ self.assertEqual(self.ec.get(self.app1, 'version'), '5')
def test_connection(self):
- self.assertEquals(len(self.ec.get_resource(self.node1).connections), 6)
- self.assertEquals(len(self.ec.get_resource(self.iface1).connections), 2)
- self.assertEquals(len(self.ec.get_resource(self.channel).connections), 1)
- self.assertEquals(len(self.ec.get_resource(self.app1).connections), 1)
- self.assertEquals(len(self.ec.get_resource(self.app2).connections), 1)
+ self.assertEqual(len(self.ec.get_resource(self.node1).connections), 6)
+ self.assertEqual(len(self.ec.get_resource(self.iface1).connections), 2)
+ self.assertEqual(len(self.ec.get_resource(self.channel).connections), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app1).connections), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app2).connections), 1)
def test_condition(self):
- self.assertEquals(len(self.ec.get_resource(self.app1).conditions[ResourceAction.STOP]), 1)
- self.assertEquals(len(self.ec.get_resource(self.app2).conditions[ResourceAction.START]), 1)
- self.assertEquals(len(self.ec.get_resource(self.app3).conditions[ResourceAction.START]), 1)
- self.assertEquals(len(self.ec.get_resource(self.app4).conditions[ResourceAction.STOP]), 1)
- self.assertEquals(len(self.ec.get_resource(self.app5).conditions[ResourceAction.START]), 2)
+ self.assertEqual(len(self.ec.get_resource(self.app1).conditions[ResourceAction.STOP]), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app2).conditions[ResourceAction.START]), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app3).conditions[ResourceAction.START]), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app4).conditions[ResourceAction.STOP]), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app5).conditions[ResourceAction.START]), 2)
class OMFVLCNormalCase(unittest.TestCase):
def test_deploy(self):
ec.wait_finished([self.app1, self.app2, self.app3,self.app4, self.app5])
- self.assertEquals(round(tdiffsec(ec.get_resource(self.app2).start_time, ec.get_resource(self.app1).start_time),0), 3.0)
- self.assertEquals(round(tdiffsec(ec.get_resource(self.app3).start_time, ec.get_resource(self.app2).start_time),0), 2.0)
- self.assertEquals(round(tdiffsec(ec.get_resource(self.app4).start_time, ec.get_resource(self.app3).start_time),0), 3.0)
- self.assertEquals(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app3).start_time),0), 20.0)
- self.assertEquals(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app1).start_time),0), 25.0)
-
- self.assertEquals(ec.get_resource(self.node1).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.channel).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.app1).state, ResourceState.STOPPED)
- self.assertEquals(ec.get_resource(self.app2).state, ResourceState.STOPPED)
- self.assertEquals(ec.get_resource(self.app3).state, ResourceState.STOPPED)
- self.assertEquals(ec.get_resource(self.app4).state, ResourceState.STOPPED)
- self.assertEquals(ec.get_resource(self.app5).state, ResourceState.STOPPED)
+ self.assertEqual(round(tdiffsec(ec.get_resource(self.app2).start_time, ec.get_resource(self.app1).start_time),0), 3.0)
+ self.assertEqual(round(tdiffsec(ec.get_resource(self.app3).start_time, ec.get_resource(self.app2).start_time),0), 2.0)
+ self.assertEqual(round(tdiffsec(ec.get_resource(self.app4).start_time, ec.get_resource(self.app3).start_time),0), 3.0)
+ self.assertEqual(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app3).start_time),0), 20.0)
+ self.assertEqual(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app1).start_time),0), 25.0)
+
+ self.assertEqual(ec.get_resource(self.node1).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.channel).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.app1).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.app2).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.app3).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.app4).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.app5).state, ResourceState.STOPPED)
ec.shutdown()
- self.assertEquals(ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app2).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app3).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app4).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app5).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app3).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app4).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app5).state, ResourceState.RELEASED)
if __name__ == '__main__':
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_hostname(self):
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_iface(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_ip(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_channel(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_app(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
def test_deploy_wo_app_path(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
if __name__ == '__main__':
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_node_and_iface_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_node_iface_channel_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_app_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2])
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
def test_deploy_with_all_nc_and_app_critical(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
self.ec.wait_finished([self.app1, self.app2, self.app3])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
def test_deploy_with_app_nc_and_critical_right(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2, self.app3])
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
def test_deploy_with_many_app_nc_and_critical(self):
self.ec.wait_finished([self.app1, self.app2, self.app3, self.app4, self.app5, self.app6])
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
- self.assertEquals(self.ec.get_resource(self.app5).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.app6).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app5).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app6).state, ResourceState.STOPPED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app4).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app5).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app6).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app4).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app5).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app6).state, ResourceState.RELEASED)
if __name__ == '__main__':
class OMFResourceFactoryTestCase(unittest.TestCase):
def test_creation_phase(self):
- self.assertEquals(OMFNode.get_rtype(), "omf::Node")
- self.assertEquals(len(OMFNode._attributes), 8)
+ self.assertEqual(OMFNode.get_rtype(), "omf::Node")
+ self.assertEqual(len(OMFNode._attributes), 8)
- self.assertEquals(OMFWifiInterface.get_rtype(), "omf::WifiInterface")
- self.assertEquals(len(OMFWifiInterface._attributes), 12)
+ self.assertEqual(OMFWifiInterface.get_rtype(), "omf::WifiInterface")
+ self.assertEqual(len(OMFWifiInterface._attributes), 12)
- self.assertEquals(OMFChannel.get_rtype(), "omf::Channel")
- self.assertEquals(len(OMFChannel._attributes), 8)
+ self.assertEqual(OMFChannel.get_rtype(), "omf::Channel")
+ self.assertEqual(len(OMFChannel._attributes), 8)
- self.assertEquals(OMFApplication.get_rtype(), "omf::Application")
- self.assertEquals(len(OMFApplication._attributes), 14)
+ self.assertEqual(OMFApplication.get_rtype(), "omf::Application")
+ self.assertEqual(len(OMFApplication._attributes), 14)
class OMFEachTestCase(unittest.TestCase):
def setUp(self):
self.ec.shutdown()
def test_creation_and_configuration_node(self):
- self.assertEquals(self.ec.get(self.node1, 'hostname'), 'wlab12')
- self.assertEquals(self.ec.get(self.node1, 'xmppUser'), 'nepi')
- self.assertEquals(self.ec.get(self.node1, 'xmppServer'), 'xmpp-plexus.onelab.eu')
- self.assertEquals(self.ec.get(self.node1, 'xmppPort'), '5222')
- self.assertEquals(self.ec.get(self.node1, 'xmppPassword'), '1234')
- self.assertEquals(self.ec.get(self.node1, 'version'), '6')
+ self.assertEqual(self.ec.get(self.node1, 'hostname'), 'wlab12')
+ self.assertEqual(self.ec.get(self.node1, 'xmppUser'), 'nepi')
+ self.assertEqual(self.ec.get(self.node1, 'xmppServer'), 'xmpp-plexus.onelab.eu')
+ self.assertEqual(self.ec.get(self.node1, 'xmppPort'), '5222')
+ self.assertEqual(self.ec.get(self.node1, 'xmppPassword'), '1234')
+ self.assertEqual(self.ec.get(self.node1, 'version'), '6')
def test_creation_and_configuration_interface(self):
- self.assertEquals(self.ec.get(self.iface1, 'name'), 'wlan0')
- self.assertEquals(self.ec.get(self.iface1, 'mode'), 'adhoc')
- self.assertEquals(self.ec.get(self.iface1, 'hw_mode'), 'g')
- self.assertEquals(self.ec.get(self.iface1, 'essid'), 'vlcexp')
- self.assertEquals(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
- self.assertEquals(self.ec.get(self.iface1, 'version'), '6')
+ self.assertEqual(self.ec.get(self.iface1, 'name'), 'wlan0')
+ self.assertEqual(self.ec.get(self.iface1, 'mode'), 'adhoc')
+ self.assertEqual(self.ec.get(self.iface1, 'hw_mode'), 'g')
+ self.assertEqual(self.ec.get(self.iface1, 'essid'), 'vlcexp')
+ self.assertEqual(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
+ self.assertEqual(self.ec.get(self.iface1, 'version'), '6')
def test_creation_and_configuration_channel(self):
- self.assertEquals(self.ec.get(self.channel, 'channel'), '6')
- self.assertEquals(self.ec.get(self.channel, 'xmppUser'), 'nepi')
- self.assertEquals(self.ec.get(self.channel, 'xmppServer'), 'xmpp-plexus.onelab.eu')
- self.assertEquals(self.ec.get(self.channel, 'xmppPort'), '5222')
- self.assertEquals(self.ec.get(self.channel, 'xmppPassword'), '1234')
- self.assertEquals(self.ec.get(self.channel, 'version'), '6')
+ self.assertEqual(self.ec.get(self.channel, 'channel'), '6')
+ self.assertEqual(self.ec.get(self.channel, 'xmppUser'), 'nepi')
+ self.assertEqual(self.ec.get(self.channel, 'xmppServer'), 'xmpp-plexus.onelab.eu')
+ self.assertEqual(self.ec.get(self.channel, 'xmppPort'), '5222')
+ self.assertEqual(self.ec.get(self.channel, 'xmppPassword'), '1234')
+ self.assertEqual(self.ec.get(self.channel, 'version'), '6')
def test_creation_and_configuration_application(self):
- self.assertEquals(self.ec.get(self.app1, 'appid'), 'Vlc#1')
- self.assertEquals(self.ec.get(self.app1, 'command'), "/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'")
- self.assertEquals(self.ec.get(self.app1, 'env'), 'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
- self.assertEquals(self.ec.get(self.app1, 'version'), '6')
+ self.assertEqual(self.ec.get(self.app1, 'appid'), 'Vlc#1')
+ self.assertEqual(self.ec.get(self.app1, 'command'), "/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'")
+ self.assertEqual(self.ec.get(self.app1, 'env'), 'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
+ self.assertEqual(self.ec.get(self.app1, 'version'), '6')
def test_connection(self):
- self.assertEquals(len(self.ec.get_resource(self.node1).connections), 6)
- self.assertEquals(len(self.ec.get_resource(self.iface1).connections), 2)
- self.assertEquals(len(self.ec.get_resource(self.channel).connections), 1)
- self.assertEquals(len(self.ec.get_resource(self.app1).connections), 1)
- self.assertEquals(len(self.ec.get_resource(self.app2).connections), 1)
+ self.assertEqual(len(self.ec.get_resource(self.node1).connections), 6)
+ self.assertEqual(len(self.ec.get_resource(self.iface1).connections), 2)
+ self.assertEqual(len(self.ec.get_resource(self.channel).connections), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app1).connections), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app2).connections), 1)
def test_condition(self):
- self.assertEquals(len(self.ec.get_resource(self.app1).conditions[ResourceAction.STOP]), 1)
- self.assertEquals(len(self.ec.get_resource(self.app2).conditions[ResourceAction.START]), 1)
- self.assertEquals(len(self.ec.get_resource(self.app3).conditions[ResourceAction.START]), 1)
- self.assertEquals(len(self.ec.get_resource(self.app4).conditions[ResourceAction.STOP]), 1)
- self.assertEquals(len(self.ec.get_resource(self.app5).conditions[ResourceAction.START]), 2)
+ self.assertEqual(len(self.ec.get_resource(self.app1).conditions[ResourceAction.STOP]), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app2).conditions[ResourceAction.START]), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app3).conditions[ResourceAction.START]), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app4).conditions[ResourceAction.STOP]), 1)
+ self.assertEqual(len(self.ec.get_resource(self.app5).conditions[ResourceAction.START]), 2)
class OMFVLCNormalCase(unittest.TestCase):
def test_deploy(self):
self.assertGreaterEqual(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app3).start_time),0), 2.0)
self.assertGreaterEqual(round(tdiffsec(ec.get_resource(self.app5).start_time, ec.get_resource(self.app1).start_time),0), 25.0)
- self.assertEquals(ec.get_resource(self.node1).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.channel).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.app1).state, ResourceState.STOPPED)
- self.assertEquals(ec.get_resource(self.app2).state, ResourceState.STOPPED)
- self.assertEquals(ec.get_resource(self.app3).state, ResourceState.STOPPED)
- self.assertEquals(ec.get_resource(self.app4).state, ResourceState.STOPPED)
- self.assertEquals(ec.get_resource(self.app5).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.node1).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.channel).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.app1).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.app2).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.app3).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.app4).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.app5).state, ResourceState.STOPPED)
ec.shutdown()
- self.assertEquals(ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app2).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app3).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app4).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app5).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app3).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app4).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app5).state, ResourceState.RELEASED)
if __name__ == '__main__':
with open("app1_err.txt", "w") as f:
f.write(stderr_1)
- self.assertEquals(ec.get_resource(self.node1).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.channel).state, ResourceState.STARTED)
- self.assertEquals(ec.get_resource(self.app1).state, ResourceState.STOPPED)
+ self.assertEqual(ec.get_resource(self.node1).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.channel).state, ResourceState.STARTED)
+ self.assertEqual(ec.get_resource(self.app1).state, ResourceState.STOPPED)
ec.shutdown()
- self.assertEquals(ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(ec.get_resource(self.app1).state, ResourceState.RELEASED)
with open("app1_out.txt", "r") as t:
l = t.readlines()
- self.assertEquals(l[0], "PING 10.0.0.17 (10.0.0.17) 56(84) bytes of data.\n")
+ self.assertEqual(l[0], "PING 10.0.0.17 (10.0.0.17) 56(84) bytes of data.\n")
self.assertIn("5 packets transmitted, 5 received, 0% packet loss, time", l[-2])
self.assertIn("rtt min/avg/max/mdev = ", l[-1])
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_hostname(self):
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_iface(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_channel(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_ip(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_app(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
def test_deploy_wo_app_path(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
if __name__ == '__main__':
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_node_and_iface_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_node_iface_channel_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1])
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_app_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2])
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
def test_deploy_with_all_nc_and_app_critical(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
class OMFVLCWrongCaseWithNonCriticalDep(unittest.TestCase):
self.ec.wait_finished([self.app1, self.app2, self.app3])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.FAILED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
def test_deploy_with_app_nc_and_critical_right(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.wait_finished([self.app1, self.app2, self.app3])
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
- #self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ #self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
def test_deploy_with_many_app_nc_and_critical(self):
self.ec.wait_finished([self.app1, self.app2, self.app3, self.app4, self.app5, self.app6])
- #self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
- #self.assertEquals(self.ec.get_resource(self.app4).state, ResourceState.STOPPED)
- self.assertEquals(self.ec.get_resource(self.app5).state, ResourceState.FAILED)
- #self.assertEquals(self.ec.get_resource(self.app6).state, ResourceState.STOPPED)
+ #self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.FAILED)
+ #self.assertEqual(self.ec.get_resource(self.app4).state, ResourceState.STOPPED)
+ self.assertEqual(self.ec.get_resource(self.app5).state, ResourceState.FAILED)
+ #self.assertEqual(self.ec.get_resource(self.app6).state, ResourceState.STOPPED)
self.ec.shutdown()
- self.assertEquals(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app4).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app5).state, ResourceState.RELEASED)
- self.assertEquals(self.ec.get_resource(self.app6).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app3).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app4).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app5).state, ResourceState.RELEASED)
+ self.assertEqual(self.ec.get_resource(self.app6).state, ResourceState.RELEASED)
if __name__ == '__main__':
print("First try to change the STDIN")
self.ec.set(self.app1, 'test', 3)
- self.assertEquals(self.ec.get(self.app1, 'test'), 30)
+ self.assertEqual(self.ec.get(self.app1, 'test'), 30)
time.sleep(3)
print("Second try to change the STDIN")
self.ec.set(self.app1, 'test', 101)
- self.assertEquals(self.ec.get(self.app1, 'test'), 1010)
+ self.assertEqual(self.ec.get(self.app1, 'test'), 1010)
self.ec.wait_finished([self.app1])
class WilabtSfaNodeFactoryTestCase(unittest.TestCase):
def test_creation_phase(self):
- self.assertEquals(WilabtSfaNode._rtype, "WilabtSfaNode")
- self.assertEquals(len(WilabtSfaNode._attributes), 17)
+ self.assertEqual(WilabtSfaNode._rtype, "WilabtSfaNode")
+ self.assertEqual(len(WilabtSfaNode._attributes), 17)
class WilabtSfaNodeTestCase(unittest.TestCase):
"""
api1 = wnode_rm1.sfaapi
self.assertIsInstance(api1, SFAAPI)
- self.assertEquals(len(api1._reserved), 0)
- self.assertEquals(len(api1._blacklist), 0)
+ self.assertEqual(len(api1._reserved), 0)
+ self.assertEqual(len(api1._blacklist), 0)
node2 = self.ec.register_resource("WilabtSfaNode")
self.ec.set(node2, "host", "zotacM20")
wnode_rm2 = self.ec.get_resource(node2)
api2 = wnode_rm2.sfaapi
- self.assertEquals(api1, api2)
+ self.assertEqual(api1, api2)
wnode_rm1.sfaapi._reserved = set()
wnode_rm1.sfaapi._blacklist = set()
host = wnode_rm.get("host")
self.assertIsNotNone(host)
- self.assertEquals(wnode_rm.sfaapi._reserved, set())
+ self.assertEqual(wnode_rm.sfaapi._reserved, set())
wnode_rm.do_discover()
- self.assertEquals(len(wnode_rm.sfaapi._reserved), 1)
- self.assertEquals(wnode_rm._node_to_provision, 'wilab2.ilabt.iminds.be.zotacE5')
+ self.assertEqual(len(wnode_rm.sfaapi._reserved), 1)
+ self.assertEqual(wnode_rm._node_to_provision, 'wilab2.ilabt.iminds.be.zotacE5')
wnode_rm.sfaapi._reserved = set()
wnode_rm.sfaapi._blacklist = set()
wnode_rm = self.ec.get_resource(node)
- self.assertEquals(wnode_rm.sfaapi._reserved, set())
+ self.assertEqual(wnode_rm.sfaapi._reserved, set())
self.assertIsNone(wnode_rm._node_to_provision)
wnode_rm.do_discover()
if not self.ec.abort and self.ec.state(node) > 2:
cmd = 'echo "IT WORKED"'
((out, err), proc) = wnode_rm.execute(cmd)
- self.assertEquals(out.strip(), "IT WORKED")
+ self.assertEqual(out.strip(), "IT WORKED")
#wnode_rm.sfaapi._reserved = set()
#wnode_rm.sfaapi._blacklist = set()
state1 = self.ec.state(node1)
state2 = self.ec.state(node2)
if not self.ec.abort:
- self.assertEquals(state1, (3, 4))
- self.assertEquals(state2, (3, 4))
+ self.assertEqual(state1, (3, 4))
+ self.assertEqual(state2, (3, 4))
self.ec.shutdown()
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):
"""
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,
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)
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)
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):
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):
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
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):
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):
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()
class PLSfaNodeFactoryTestCase(unittest.TestCase):
def test_creation_phase(self):
- self.assertEquals(PlanetlabSfaNode._rtype, "planetlab::sfa::Node")
- self.assertEquals(len(PlanetlabSfaNode._attributes), 31)
+ self.assertEqual(PlanetlabSfaNode._rtype, "planetlab::sfa::Node")
+ self.assertEqual(len(PlanetlabSfaNode._attributes), 31)
class PLSfaNodeTestCase(unittest.TestCase):
"""
api1 = plnode_rm1.sfaapi
self.assertIsInstance(api1, SFAAPI)
- self.assertEquals(len(api1._reserved), 0)
- self.assertEquals(len(api1._blacklist), 0)
+ self.assertEqual(len(api1._reserved), 0)
+ self.assertEqual(len(api1._blacklist), 0)
node2 = self.ec.register_resource("planetlab::sfa::Node")
self.ec.set(node2, "hostname", "planetlab2.ionio.gr")
plnode_rm2 = self.ec.get_resource(node2)
api2 = plnode_rm2.sfaapi
- self.assertEquals(api1, api2)
+ self.assertEqual(api1, api2)
@skipIfNotSfaCredentials
def test_discover(self):
hostname = plnode_rm.get("hostname")
self.assertIsNotNone(hostname)
- self.assertEquals(len(plnode_rm.sfaapi._reserved), 0)
+ self.assertEqual(len(plnode_rm.sfaapi._reserved), 0)
plnode_rm.do_discover()
- self.assertEquals(len(plnode_rm.sfaapi._reserved), 1)
- self.assertEquals(plnode_rm._node_to_provision, 'ple.mimuw.roti.mimuw.edu.pl')
+ self.assertEqual(len(plnode_rm.sfaapi._reserved), 1)
+ self.assertEqual(plnode_rm._node_to_provision, 'ple.mimuw.roti.mimuw.edu.pl')
plnode_rm.sfaapi._reserved = set()
plnode_rm.sfaapi._blacklist = set()
plnode_rm = self.ec.get_resource(node)
- self.assertEquals(plnode_rm.sfaapi._reserved, set())
+ self.assertEqual(plnode_rm.sfaapi._reserved, set())
self.assertIsNone(plnode_rm._node_to_provision)
plnode_rm.do_discover()
cmd = 'echo "IT WORKED"'
((out, err), proc) = plnode_rm.execute(cmd)
- self.assertEquals(out.strip(), "IT WORKED")
+ self.assertEqual(out.strip(), "IT WORKED")
plnode_rm.sfaapi._reserved = set()
plnode_rm.sfaapi._blacklist = set()
self.assertIsInstance(api1, MANIFOLDAPI)
self.assertIsInstance(api2, MANIFOLDAPI)
- self.assertEquals(api1, api2)
+ self.assertEqual(api1, api2)
class MANIFOLDAPITestCase(unittest.TestCase):
r_info = self.api.get_resource_info(filters=filters)
hostname = r_info[0]['hostname']
- self.assertEquals(hostname, 'planetlab2.tlm.unavarra.es')
+ self.assertEqual(hostname, 'planetlab2.tlm.unavarra.es')
# query with 2 filters
filters['network'] = 'ple'
r_info = self.api.get_resource_info(filters=filters)
hostname = r_info[0]['hostname']
- self.assertEquals(hostname, 'planetlab2.tlm.unavarra.es')
+ self.assertEqual(hostname, 'planetlab2.tlm.unavarra.es')
# query with fields only, without filters
fields = ['latitude','longitude']
r_info = self.api.get_resource_info(fields=fields)
value = r_info[10]
- self.assertEquals(value.keys(), fields)
+ self.assertEqual(value.keys(), fields)
# query with 2 filters and 2 fields
r_info = self.api.get_resource_info(filters, fields)
value = r_info[0]
result = {'latitude': '42.7993', 'longitude': '-1.63544'}
- self.assertEquals(value, result)
+ self.assertEqual(value, result)
# query with filters where the AND should be zero resources
filters['network'] = 'omf'
r_info = self.api.get_resource_info(filters, fields)
- self.assertEquals(r_info, [])
+ self.assertEqual(r_info, [])
def test_fail_if_invalid_field(self):
"""
'urn:publicid:IDN+ple:uttple+node+planetlab2.utt.fr',
'urn:publicid:IDN+ple:lilleple+node+node1pl.planet-lab.telecom-lille1.eu']
- self.assertEquals(resources, result)
+ self.assertEqual(resources, result)
def test_update_resources_from_slice(self):
"""
runner.destroy()
- self.assertEquals(count[0], 10)
+ self.assertEqual(count[0], 10)
def test_run_interrupt(self):
runner.destroy()
- self.assertEquals(count[0], 4)
+ self.assertEqual(count[0], 4)
self.assertRaises(RuntimeError, runner.sync)
ec2.wait_finished(apps)
ec2.shutdown()
- self.assertEquals(len(ec.resources), len(ec2.resources))
+ self.assertEqual(len(ec.resources), len(ec2.resources))
shutil.rmtree(dirpath)
(outremote, errrmote), premote = rexec(command, host, user,
port = env.port, agent = True)
- self.assertEquals(outlocal, outremote)
+ self.assertEqual(outlocal, outremote)
def test_rcopy_list(self):
env = test_environment()
port = env.port,
agent = True)
- self.assertEquals(status, ProcStatus.RUNNING)
+ self.assertEqual(status, ProcStatus.RUNNING)
rkill(pid, ppid,
host = host,
port = env.port,
agent = True)
- self.assertEquals(status, ProcStatus.FINISHED)
+ self.assertEqual(status, ProcStatus.FINISHED)
if __name__ == '__main__':
seconds1 = _get_total_seconds(date)
seconds2 = date.total_seconds()
- self.assertEquals(seconds1, seconds2)
+ self.assertEqual(seconds1, seconds2)
if __name__ == '__main__':