i.create() # should create and set peer on far host
self.assertTrue(h2.cli.grep_cmd('ip l', 'testp'))
self.assertTrue(LinuxCLI().grep_cmd('ip l', 'testi'))
self.assertFalse(LinuxCLI().grep_cmd('ip l', 'testi.p'))
i.config_addr()
# the far iface should be controllable on its own just like any interface
p.add_ip('192.168.1.2')
p.up()
self.assertTrue(h2.cli.grep_cmd('ip a | grep testp | grep inet | sed -e "s/^ *//" | cut -f 2 -d " "',
'192.168.1.2'))
i.remove() # should remove both interfaces
self.assertFalse(h2.cli.grep_cmd('ip l', 'testp'))
self.assertFalse(LinuxCLI().grep_cmd('ip l', 'testi'))
h2.remove()
def tearDown(self):
LinuxCLI().cmd('ip l del testi')
LinuxCLI().cmd('ip netns del test2')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(VirtualInterfaceTest)
cfg = json.load(f)
ptc = PhysicalTopologyConfig.make_physical_topology(cfg)
self.assertTrue('root' in ptc.hosts)
self.assertTrue('zoo1eth0' in ptc.hosts['root'].interfaces)
self.assertTrue('zoo1' in ptc.hosts)
self.assertTrue('eth0' in ptc.hosts['zoo1'].interfaces)
#self.assertTrue('cass1' in ptc.hosts)
self.assertTrue('cmp1' in ptc.hosts)
self.assertTrue('root' in ptc.implementation)
self.assertTrue(ptc.implementation['root'].impl == 'PTM.RootHost')
self.assertTrue('zoo1' in ptc.implementation)
self.assertTrue(ptc.implementation['zoo1'].impl == 'PTM.ZookeeperHost')
self.assertTrue(len(ptc.wiring) > 0)
self.assertEquals(ptc.wiring['root']['zoo1eth0'].host, 'zoo1')
self.assertEquals(ptc.wiring['root']['zoo1eth0'].interface, 'eth0')
self.assertEquals(ptc.wiring['edge1']['eth0'].host, 'cmp1')
self.assertEquals(ptc.wiring['edge1']['eth0'].interface, 'eth1')
self.assertTrue('root' in ptc.host_start_order)
self.assertTrue('external1' in ptc.host_start_order)
self.assertTrue('test-host1' in ptc.host_start_order)
self.assertTrue('test-host2' in ptc.host_start_order)
self.assertTrue('zoo1' in ptc.host_start_order)
#self.assertTrue('cass1' in ptc.host_start_order)
self.assertTrue('cmp1' in ptc.host_start_order)
self.assertTrue('edge1' in ptc.host_start_order)
from CBT.UnitTestRunner import run_unit_test
run_unit_test(PhysicalTopologyConfigTest)
port1 = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
port2 = "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
virtual_host1 = Guest(vm1)
virtual_host1.plugin_vm('eth0', port1)
virtual_host2 = Guest(vm2)
virtual_host2.plugin_vm('eth0', port2)
# No virtual bridge between VMs means they should NOT talk to each other yet.
self.assertFalse(virtual_host1.ping('eth0', '10.55.55.55'))
virtual_host1.unplug_vm(port1)
virtual_host2.unplug_vm(port2)
finally:
vm1.net_down()
vm2.net_down()
vm1.shutdown()
vm2.shutdown()
vm1.remove()
vm2.remove()
@classmethod
def tearDownClass(cls):
cls.ptm.shutdown()
LinuxCLI().cmd('ip netns del vm1')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(GuestTest)
self.assertTrue(h1.cli.grep_cmd('ip a | grep testi', '192.168.1.1'))
self.assertTrue(h2.cli.grep_cmd('ip a | grep testp', '192.168.1.3'))
h1.net_down()
h2.net_down()
h2.shutdown()
h2.remove()
self.assertFalse(h1.cli.grep_cmd('ip netns', 'test2'))
h1.shutdown()
h1.remove()
#def test_send_packet(self):
#h1.send_packet('eth0', 'icmp', '10.0.1.3')
#self.assertEqual(True, False)
#def test_connect_iface_to_port(self):
#self.assertEqual(True, False)
def tearDown(self):
LinuxCLI().cmd('ip netns del test')
LinuxCLI().cmd('ip netns del test2')
LinuxCLI().cmd('ip l set br0 down')
LinuxCLI().cmd('brctl delbr br0')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(NetNSHostTest)
self.assertTrue(root_host.cli.grep_cmd('ip l', 'th1eth1'))
self.assertTrue(test_host1.cli.grep_cmd('ip l', 'eth1'))
ptm.shutdown()
self.assertFalse(LinuxCLI().grep_cmd('ip netns', 'zoo1'))
self.assertFalse(LinuxCLI().grep_cmd('ip netns', 'test-host1'))
def tearDown(self):
#LinuxCLI().cmd('ip netns del cass1')
LinuxCLI().cmd('ip netns del cmp1')
LinuxCLI().cmd('ip netns del zoo1')
LinuxCLI().cmd('ip netns del edge1')
LinuxCLI().cmd('ip netns del external1')
LinuxCLI().cmd('ip netns del test-host1')
LinuxCLI().cmd('ip netns del test-host2')
LinuxCLI().cmd('ip l set dev br0 down')
LinuxCLI().cmd('ip l set dev brv0 down')
LinuxCLI().cmd('ip l del zoo1eth0')
LinuxCLI().cmd('ip l del cmp1eth0')
#LinuxCLI().cmd('ip l del cass1eth0')
LinuxCLI().cmd('ip l del th1eth0')
LinuxCLI().cmd('ip l del th1eth1')
LinuxCLI().cmd('ip l del th2eth0')
LinuxCLI().cmd('brctl delbr br0')
LinuxCLI().cmd('brctl delbr brv0')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(PhysicalTopologyManagerTest)
self.assertFalse(True)
pass
class TestCaseTest(unittest.TestCase):
def test_test_case_scenarios(self):
tc = SampleTestCase()
self.assertEquals('SampleTestCase', tc._get_name())
self.assertIn(SampleScenario, tc.supported_scenarios())
def test_test_case_run(self):
tc = SampleTestCase('test_basic')
tc._prepare_class(SampleScenario(None, None))
tr = unittest.TestResult()
tc.run(tr)
self.assertEquals(0, len(tr.errors))
self.assertEquals(1, len(tr.failures))
tc = SampleTestCase('test_a_failure')
tc._prepare_class(SampleScenario(None, None))
tr = unittest.TestResult()
tc.run(tr)
self.assertEquals(0, len(tr.errors))
self.assertEquals(1, len(tr.failures))
from CBT.UnitTestRunner import run_unit_test
run_unit_test(TestCaseTest)
for h in ptm.host_by_start_order:
h.remove()
def tearDown(self):
pass
LinuxCLI().cmd('ip netns del cmp1')
#LinuxCLI().cmd('ip netns del cass1')
LinuxCLI().cmd('ip netns del zoo1')
LinuxCLI().cmd('ip netns del vm1')
LinuxCLI().cmd('ip l del cmp1eth0')
#LinuxCLI().cmd('ip l del cass1eth0')
LinuxCLI().cmd('ip l del zoo1eth0')
LinuxCLI().cmd('ip l set br0 down')
LinuxCLI().cmd('brctl delbr br0')
#if LinuxCLI().exists('/var/run/cassandra.1/cassandra.pid'):
# pid = LinuxCLI().read_from_file('/var/run/cassandra.1/cassandra.pid')
# LinuxCLI().cmd('kill ' + str(pid))
if LinuxCLI().exists('/var/run/zookeeper.1/pid'):
pid = LinuxCLI().read_from_file('/var/run/zookeeper.1/pid')
LinuxCLI().cmd('kill ' + str(pid))
if LinuxCLI().exists('/var/run/midolman.1/pid'):
pid = LinuxCLI().read_from_file('/var/run/midolman.1/pid')
LinuxCLI().cmd('kill ' + str(pid))
if LinuxCLI().exists('/var/run/midolman.1/dnsmasq.pid'):
pid = LinuxCLI().read_from_file('/var/run/midolman.1/dnsmasq.pid')
LinuxCLI().cmd('kill ' + str(pid))
from CBT.UnitTestRunner import run_unit_test
run_unit_test(ComputeHostTest)
self.assertTrue(cli.grep_file("/etc/hosts", "13.13.13.13 baz"))
self.assertTrue(cli.grep_file("/etc/hosts", "6.6.6.6 foobar"))
self.assertTrue(cli.grep_file("/etc/hosts", "9.9.9.9 bamf blaze"))
self.assertTrue(cli.grep_file("/etc/hosts", "11.11.11.11 test"))
self.assertTrue(cli.grep_file("/etc/hosts", "6.6.6.6 baz2"))
self.assertTrue(cli.grep_file("/etc/hosts", "13.13.13.13 baz"))
self.assertEqual(1, len(cli.cmd('grep "13.13.13.13 baz" /etc/hosts').splitlines(False)))
self.assertFalse(cli.grep_file("/etc/hosts", "12.12.12.12 baz"))
finally:
cli.copy_file("/etc/hosts", "/tmp/hosts.tested")
cli.move("/etc/hosts.backup", "/etc/hosts")
def test_pid_functions(self):
cli = LinuxCLI()
root_pids = cli.get_process_pids("root")
pids = cli.get_running_pids()
ppids = cli.get_parent_pids("1")
self.assertTrue(len(root_pids) > 0)
self.assertTrue(len(pids) > 0)
self.assertTrue(len(ppids) > 0)
def tearDown(self):
LinuxCLI().rm("tmp-test")
from CBT.UnitTestRunner import run_unit_test
run_unit_test(CLITest)
h.shutdown()
for h in reversed(ptm.host_by_start_order):
h.remove()
def tearDown(self):
pass
LinuxCLI().cmd('ip netns del cmp1')
#LinuxCLI().cmd('ip netns del cass1')
LinuxCLI().cmd('ip netns del zoo1')
LinuxCLI().cmd('ip l del cmp1eth0')
#LinuxCLI().cmd('ip l del cass1eth0')
LinuxCLI().cmd('ip l del zoo1eth0')
LinuxCLI().cmd('ip l set br0 down')
LinuxCLI().cmd('brctl delbr br0')
#if LinuxCLI().exists('/var/run/cassandra.1/cassandra.pid'):
# pid = LinuxCLI().read_from_file('/var/run/cassandra.1/cassandra.pid')
# LinuxCLI().cmd('kill ' + str(pid))
if LinuxCLI().exists('/var/run/zookeeper.1/pid'):
pid = LinuxCLI().read_from_file('/var/run/zookeeper.1/pid')
LinuxCLI().cmd('kill ' + str(pid))
if LinuxCLI().exists('/var/run/midolman.1/pid'):
pid = LinuxCLI().read_from_file('/var/run/midolman.1/pid')
LinuxCLI().cmd('kill ' + str(pid))
if LinuxCLI().exists('/var/run/midolman.1/dnsmasq.pid'):
pid = LinuxCLI().read_from_file('/var/run/midolman.1/dnsmasq.pid')
LinuxCLI().cmd('kill ' + str(pid))
from CBT.UnitTestRunner import run_unit_test
run_unit_test(NetworkHostTest)
self.assertAlmostEquals(2, LinuxCLI().wc('./sliced-logs/test3.1.slice')['lines'], delta=1)
self.assertAlmostEquals(2, LinuxCLI().wc('./sliced-logs/test-log.slice')['lines'], delta=1)
self.assertAlmostEquals(2, LinuxCLI().wc('./sliced-logs/test-log2.slice')['lines'], delta=1)
finally:
LinuxCLI().rm('./logs')
LinuxCLI().rm('./sliced-logs')
LinuxCLI().rm('./logs-all')
LinuxCLI().rm('./logs2')
LinuxCLI().rm('./logs3')
LinuxCLI().rm('./logs4')
@classmethod
def tearDownClass(cls):
LinuxCLI().rm('log_file.txt')
LinuxCLI().rm('log_file2.txt')
LinuxCLI().rm('log_tee.txt')
LinuxCLI().rm('log_name_generation.txt')
LinuxCLI().rm('log_levels.txt')
LinuxCLI().rm('log_multiple.txt')
LinuxCLI().rm('log_multiple2.txt')
LinuxCLI().rm('logs')
LinuxCLI().rm('logs2')
LinuxCLI().rm('logs3')
LinuxCLI().rm('logs4')
LinuxCLI().rm('logs-all')
LinuxCLI().rm('sliced-logs')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(LogManagerTest)
from common.CLI import LinuxCLI
from PTM.Host import Host
from PTM.Interface import Interface
class InterfaceTest(unittest.TestCase):
def test_use_active_iface(self):
cli = LinuxCLI(log_cmd=True)
h = Host('test', None, cli, lambda name: None, lambda name: None)
i = Interface('testi', h, ip_addr=['192.168.0.2'])
cli.cmd('ip l add dev testi type dummy')
self.assertTrue(cli.grep_cmd('ip l | grep testi', 'state DOWN'))
i.up()
time.sleep(1)
self.assertTrue(cli.grep_cmd('ip l | grep testi', 'UP'))
i.down()
self.assertFalse(cli.grep_cmd('ip l | grep testi', 'UP'))
cli.cmd('ip l del testi')
def tearDown(self):
LinuxCLI().cmd('ip l del testi')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(InterfaceTest)
port1 = main_bridge.add_port().create()
""" :type: Port"""
port2 = main_bridge.add_port().create()
""" :type: Port"""
vm1 = vtm.create_vm(ip='10.1.1.2', preferred_hv_host='cmp1')
vm2 = vtm.create_vm(ip='10.1.1.3', preferred_hv_host='cmp2')
try:
vm1.plugin_vm('eth0', port1.get_id())
vm2.plugin_vm('eth0', port2.get_id())
self.assertTrue(vm1.ping(on_iface='eth0', target_ip='10.1.1.3'))
self.assertTrue(vm2.ping(on_iface='eth0', target_ip='10.1.1.2'))
finally:
vm1.terminate()
vm2.terminate()
port1.delete()
port2.delete()
main_bridge.delete()
@classmethod
def tearDownClass(cls):
cls.ptm.shutdown()
LinuxCLI().cmd('ip netns del vm1')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(MNAPITest)
self.assertEqual(PCAPIP4, pmap['ethernet'].next_parse_recommendation)
def test_full_packet_parsing_l3_parse_error2(self):
full_eii_packet_data = \
[0x00, 0x04, 0x00, 0x01, 0x00, 0x06, 0x08, 0x00, 0x27, 0xc6, 0x25, 0x01, 0x00, 0x00, 0x08, 0x00,
0x41, 0x10, 0x00, 0x5c, 0x93, 0x06, 0x40, 0x00, 0x40, 0x06, 0x8f, 0x75, 0x0a, 0x00, 0x02, 0x0f,
0x0a, 0x00, 0x02, 0x02, 0x00, 0x16, 0xd1, 0xf4, 0x52, 0x1a, 0x58, 0x7c, 0x58, 0x25, 0x2e, 0x9b,
0x50, 0x18, 0x9f, 0xb0, 0x18, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x00 ]
packet = PCAPPacket(full_eii_packet_data, '13:00')
self.assertRaises(PacketParsingException, packet.parse, [PCAPSLL])
pmap = packet.layer_data
emap = packet.extra_data
self.assertEqual(1, len(emap['parse_errors.ip']))
self.assertRegexpMatches(emap['parse_errors.ip'][0], 'field must be at least')
self.assertEqual('13:00', packet.timestamp)
self.assertTrue('ethernet' in pmap)
self.assertEqual(PCAPSLL, type(pmap['ethernet']))
self.assertEqual('08:00:27:c6:25:01', pmap['ethernet'].source_mac)
self.assertEqual('00:00:00:00:00:00', pmap['ethernet'].dest_mac)
self.assertEqual(PCAPIP4, pmap['ethernet'].next_parse_recommendation)
from CBT.UnitTestRunner import run_unit_test
run_unit_test(PCAPPacketTest)
interface=lo_iface,
packet_type="tcp",
count=5,
source_ip="127.0.0.1",
dest_ip="127.0.0.1",
dest_port=6055,
source_port=6015,
)
ret = tcpd.wait_for_packets(count=3, timeout=3)
self.assertEqual(3, len(ret))
ret = tcpd.wait_for_packets(count=1, timeout=3)
self.assertEqual(1, len(ret))
proc = tcpd.stop_capture()
ret = tcpd.wait_for_packets(count=1, timeout=3)
self.assertEqual(1, len(ret))
self.assertTrue(not proc.is_alive())
def tearDown(self):
time.sleep(2)
LinuxCLI().rm("tcp.callback.out")
LinuxCLI().rm("tcp.out")
from CBT.UnitTestRunner import run_unit_test
run_unit_test(TCPDumpTest)
self.assertEqual(api.get_client().get_option('option1'), 'test3')
def test_subnet(self):
api = VirtualTopologyManager(physical_topology_manager=None,
client_api_impl=MockClient())
subnet = {
'subnet': {
'name': 'test-l2',
'enable_dhcp': True,
'network_id': 'b6c86193-024c-4aeb-bd9c-ffc747bb8a74',
'tenant_id': 'mdts2-ft2015-03-10 06:03:17',
'dns_nameservers': [],
'ipv6_ra_mode': None,
'allocation_pools': [
{
'start': '1.1.1.2',
'end': '1.1.1.254'}],
'gateway_ip': '1.1.1.1',
'ipv6_address_mode': None,
'ip_version': 4,
'host_routes': [],
'cidr': '1.1.1.0/24',
'id': '6c838ffc-6a40-49ba-b363-6380b0a7dae6'}}
api.get_client().set_subnet(subnet)
self.assertEqual(api.get_client().show_subnet(), subnet)
from CBT.UnitTestRunner import run_unit_test
run_unit_test(VirtualTopologyManagerUnitTest)
def test_send_packet_tcp_real(self):
cli = LinuxCLI(debug=True)
out = TCPSender.send_packet(cli, interface='eth0', packet_type='tcp',
source_ip='1.1.1.1', dest_ip='2.2.2.2',
source_port=22, dest_port=80)
self.assertTrue('mz eth0' in out)
self.assertTrue('"sp=22,dp=80"' in out)
self.assertTrue('-A 1.1.1.1' in out)
self.assertTrue('-B 2.2.2.2' in out)
self.assertTrue('-a' not in out)
self.assertTrue('-b' not in out)
self.assertTrue('tcp' in out)
def test_send_packet_and_receive_packet(self):
cli = LinuxCLI(debug=True)
out = TCPSender.send_packet(cli, interface='eth0', packet_type='arp',
source_ip='1.1.1.1', dest_ip='2.2.2.2',
packet_options={'command': 'request', 'sip': '1.1.1.1'})
self.assertTrue('mz eth0' in out)
self.assertTrue('-t arp "request, sip=1.1.1.1"' in out)
self.assertTrue('-A 1.1.1.1' in out)
self.assertTrue('-B 2.2.2.2' in out)
self.assertTrue('-a' not in out)
self.assertTrue('-b' not in out)
self.assertTrue('icmp' not in out)
self.assertTrue('targetip' not in out)
from CBT.UnitTestRunner import run_unit_test
run_unit_test(TCPSenderTest)
edge1.wait_for_process_stop()
time.sleep(1)
self.assertFalse(bgpd_pid in LinuxCLI().get_running_pids())
root.net_down()
edge1.net_down()
root.shutdown()
edge1.shutdown()
root.remove()
edge1.remove()
def tearDown(self):
LinuxCLI().cmd('ip netns del edge1')
LinuxCLI().cmd('ip l del edge1eth0')
LinuxCLI().cmd('ip l set br0 down')
LinuxCLI().cmd('brctl delbr br0')
if LinuxCLI().exists('/var/run/quagga.1/bgpd.pid'):
pid = LinuxCLI().read_from_file('/var/run/quagga.1/bgpd.pid')
LinuxCLI().cmd('kill ' + str(pid))
if LinuxCLI().exists('/var/run/quagga.1/zebra.pid'):
pid = LinuxCLI().read_from_file('/var/run/quagga.1/zebra.pid')
LinuxCLI().cmd('kill ' + str(pid))
if LinuxCLI().exists('/var/run/quagga.1/watchquagga.pid'):
pid = LinuxCLI().read_from_file('/var/run/quagga.1/watchquagga.pid')
LinuxCLI().cmd('kill ' + str(pid))
from CBT.UnitTestRunner import run_unit_test
run_unit_test(RouterHostTest)
import unittest
from common.FileLocation import *
from common.CLI import LinuxCLI
class FileLocationTest(unittest.TestCase):
def test_get_file(self):
try:
cli = LinuxCLI(priv=False)
cli.write_to_file('test', 'teststr')
cli.write_to_file('testdir/test2', 'test2str')
fl = FileLocation('test')
self.assertEqual('.', fl.path)
fl.get_file(FileAccessor(), near_filename='test_copy')
self.assertTrue(cli.exists('test_copy'))
fl2 = FileLocation('testdir/test2')
self.assertEqual('testdir', fl2.path)
#fl2.get_file(SSHFileAccessor('localhost', LinuxCLI().whoami()), near_filename='test2_copy')
#self.assertTrue(cli.exists('test2_copy'))
finally:
LinuxCLI().rm('test')
LinuxCLI().rm('testdir')
LinuxCLI().rm('test_copy')
LinuxCLI().rm('test2_copy')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(FileLocationTest)
vm_host1.start_capture('lo', save_dump_file=True, save_dump_filename='tcp.vmhost.out')
ping_ret = vm_host1.ping('10.50.50.3')
vm_host1.send_tcp_packet(iface='lo', dest_ip='10.50.50.3', source_port=6015, dest_port=6055)
ret1 = vm_host1.capture_packets('lo', count=1, timeout=5)
ret2 = vm_host1.capture_packets('lo', count=1, timeout=5)
vm_host1.stop_capture('lo')
self.assertTrue(ping_ret)
self.assertEquals(1, len(ret1))
finally:
vm_host1.shutdown()
vm_host1.remove()
def tearDown(self):
self.root_host.net_down()
self.hypervisor.net_down()
self.hypervisor.shutdown()
self.root_host.shutdown()
self.hypervisor.remove()
self.root_host.remove()
LinuxCLI().cmd('ip netns del test_vm')
LinuxCLI().rm('tcp.vmhost.out')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(VMHostTest)
PCAP_NotEqual('ip[0] & 0xf', '5'),
PCAP_LessThanEqual('len', '1500')
])
])
expected_str = \
'( ' \
'( not ( ether multicast ) ) and ' \
'( ' \
'( ether src host bar ) or ' \
'( net 192.168.0.0 mask 255.255.255.0 ) ' \
') and ' \
'( len > 80 ) ' \
') and ' \
'( dst port 80 ) and ' \
'( ' \
'( src portrange 30000-50000 ) or ' \
'( ip proto tcp ) or ' \
'( not ( ether broadcast ) ) ' \
') and ' \
'( ' \
'( ether[0] & 1 != 0 ) and ' \
'( ip[0] & 0xf != 5 ) and ' \
'( len <= 1500 ) ' \
')'
self.assertEqual(expected_str, complex_rule.to_str())
from CBT.UnitTestRunner import run_unit_test
run_unit_test(PCAPRulesTest)
b = Bridge('test-bridge', h, ip_addr=['192.168.0.240'], options=['stp'])
b.create()
time.sleep(1)
# Check bridge is present
self.assertTrue(h.cli.grep_cmd('brctl show | grep test-bridge | cut -f 1', 'test-bridge'))
# Check STP
self.assertTrue(h.cli.grep_cmd('brctl show | grep test-bridge | cut -f 4', 'yes'))
b.link_interface(i)
time.sleep(1)
# Check interface has bridge set as link
self.assertTrue(h.cli.grep_cmd('ip l | grep testi', 'test-bridge'))
b.remove()
i.remove()
self.assertFalse(cli.grep_cmd('ip l', 'testi'))
self.assertFalse(cli.grep_cmd('brctl show', 'test-bridge'))
@classmethod
def tearDownClass(cls):
LinuxCLI().cmd('ip l del test-bridge')
LinuxCLI().cmd('brctl delbr test-bridge')
LinuxCLI().cmd('ip l del testi')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(BridgeTest)
print("Host control process error output: ")
print stderr
if stop_process.returncode != 0:
raise SubprocessFailedException('Host control stop failed with: ' + str(stop_process.returncode))
cass1.wait_for_process_stop()
time.sleep(1)
self.assertFalse(LinuxCLI().is_pid_running(pid))
root.net_down()
cass1.net_down()
root.shutdown()
cass1.shutdown()
root.remove()
cass1.remove()
def tearDown(self):
pass
LinuxCLI().cmd('ip netns del cass1')
LinuxCLI().cmd('ip l del cass1eth0')
LinuxCLI().cmd('ip l set br0 down')
LinuxCLI().cmd('brctl delbr br0')
if LinuxCLI().exists('/var/run/cassandra.1/cassandra.pid'):
pid = LinuxCLI().read_from_file('/var/run/cassandra.1/cassandra.pid')
LinuxCLI().cmd('kill ' + str(pid))
"""
from CBT.UnitTestRunner import run_unit_test
run_unit_test(CassandraHostTest)
for tc, err in results[s].errors:
print "------------------------------"
print "Test Case ERROR: [" + tc._get_name() + "]"
print "Error Message:"
print err
def test_multi_case_multi_scenario_filter_no_topo(self):
lm = LogManager(root_dir="test-logs")
tsm = TestSystemManager(None, None, log_manager=lm)
tsm.configure_logging(debug=True)
tsm.add_test(SampleTestCase)
tsm.add_test(SampleOtherTestCase)
results = tsm.run_all_tests([SampleOtherTestScenario])
self.assertNotIn(SampleTestScenario, results)
self.assertIn(SampleOtherTestScenario, results)
self.assertEqual(2, results[SampleOtherTestScenario].testsRun)
self.assertEqual(1, len(results[SampleOtherTestScenario].failures))
self.assertEqual(1, len(results[SampleOtherTestScenario].successes))
self.assertEqual(0, len(results[SampleOtherTestScenario].errors))
from CBT.UnitTestRunner import run_unit_test
run_unit_test(TestSystemManagerTest)
stdout, stderr = stop_process.communicate()
stop_process.poll()
print("Host control process output: ")
print stdout
print("Host control process error output: ")
print stderr
if stop_process.returncode != 0:
raise SubprocessFailedException('Host control start failed with: ' + str(stop_process.returncode))
zoo1.wait_for_process_stop()
time.sleep(1)
self.assertFalse(LinuxCLI().is_pid_running(pid))
root.net_down()
zoo1.net_down()
root.shutdown()
zoo1.shutdown()
root.remove()
zoo1.remove()
def tearDown(self):
LinuxCLI().cmd('ip netns del zoo1')
LinuxCLI().cmd('ip l del zoo1eth0')
LinuxCLI().cmd('ip l set br0 down')
LinuxCLI().cmd('brctl delbr br0')
from CBT.UnitTestRunner import run_unit_test
run_unit_test(ZookeeperTest)
self.assertEqual(expected, mn_version)
def test_version_strings(self):
linux_dist = version_config.get_linux_dist()
self.assertTrue(linux_dist == version_config.LINUX_CENTOS or linux_dist == version_config.LINUX_UBUNTU)
test_list = [
(("2:5.0", "201509090010.2f5a1d9"), "2:5.0.0-201509090010.2f5a1d9"),
(("05.02", "0.0.201509011045.80d8d50"), "5.2.0-201509011045.80d8d50"),
(("1.9.5", "rc3"), "1.9.5-rc3"),
(("5.0", "0.0.201509011045.80d8d50.el7"), "5.0.0-201509011045.80d8d50"),
(("1.8.9", "0.1.rc0.el7"), "1.8.9-rc0"),
(("1.9.4", "rc0"), "1.9.4-rc0"),
]
for args, expected in test_list:
mn_version = version_config.parse_midolman_version(*args)
self.assertEqual(expected, str(mn_version))
def test_vars(self):
print version_config.ConfigMap.get_configured_parameter("mn_version", config_json=CFG_FILE)
print version_config.ConfigMap.get_configured_parameter("cmd_list_datapath", config_json=CFG_FILE)
print version_config.ConfigMap.get_configured_parameter("option_config_mnconf", config_json=CFG_FILE)
print version_config.ConfigMap.get_configured_parameter("option_use_v2_stack", config_json=CFG_FILE)
print version_config.get_linux_dist()
from CBT.UnitTestRunner import run_unit_test
run_unit_test(VersionConfigTest)
vm1.plugin_vm('eth0', port1['id'], port1['mac_address'])
vm2.plugin_vm('eth0', port2['id'], port2['mac_address'])
self.assertTrue(vm1.ping(on_iface='eth0', target_ip=ip2))
finally:
if vm1 is not None:
vm1.terminate()
if vm2 is not None:
vm2.terminate()
if port1 is not None:
self.api.delete_port(port1['id'])
if port2 is not None:
self.api.delete_port(port2['id'])
@classmethod
def tearDownClass(cls):
log = logging.getLogger("neutronclient")
log.setLevel(logging.DEBUG)
try:
cls.ptm.shutdown()
LinuxCLI().cmd('ip netns del vm1')
finally:
clean_neutron(cls.api, log=log)
from CBT.UnitTestRunner import run_unit_test
run_unit_test(NeutronAPITest)
