def setUp(self): arg = {"host": "localhost", "user": "******", "password": "******"} stub = "/tmp/service_stub.py" ## service interface self.__service = ServiceTestUtils("python " + stub, **arg) ## remote interface self.__interface = RemoteInterfaceImpl(**arg) ## env.yml parameter self.__parameter = {"servers":[{"name": "s1", "image": "local/centos", "IPs": [{"dev": "eth0", "IP": "192.168.0.1/24", "gw": "192.168.0.254/24"}]}, {"name": "s2", "image": "local/centos", "IPs": [{"dev": "eth0", "IP": "192.168.0.2/24"}, {"dev": "eth1", "IP": "192.168.1.2/24", "gw": "192.168.1.254/24"}]}]} ## test utils self.__utils = DockerContainerTestUtils(**arg) ## environment definition file self.__filename = "/tmp/env.yml" # make service stub script f = open(stub, "w") f.write("import sys\n") f.write("sys.path.append('/vagrant')\n") f.write("from dockerEE.service import EnvironmentEmulationService\n") f.write("service = EnvironmentEmulationService('localhost', 'vagrant', 'vagrant')\n") f.write("service.action()") f.close() # make env.yml f = open(self.__filename, "w") f.write("---\n") f.write("servers:\n") for p in self.__parameter["servers"]: f.write(" - name: " + p["name"] + "\n") f.write(" image: " + p["image"] + "\n") f.write(" IPs:\n") for n in p["IPs"]: f.write(" - dev: " + n["dev"] + "\n") f.write(" IP: " + n["IP"] + "\n") if "gw" in n: f.write(" gw: " + n["gw"] + "\n") f.close()
def setUp(self): arg = {"host": "localhost", "user": "******", "password": "******"} ## remote interface self.__interface = RemoteInterfaceImpl(**arg) ## container_manager self.__manager = ContainerManagerImpl(**arg) ## test utils self.__utils = DockerContainerTestUtils(**arg)
class TestEnvironmentEmulationService(unittest.TestCase): ## init test case # @param self The object pointer def setUp(self): arg = {"host": "localhost", "user": "******", "password": "******"} stub = "/tmp/service_stub.py" ## service interface self.__service = ServiceTestUtils("python " + stub, **arg) ## remote interface self.__interface = RemoteInterfaceImpl(**arg) ## env.yml parameter self.__parameter = {"servers":[{"name": "s1", "image": "local/centos", "IPs": [{"dev": "eth0", "IP": "192.168.0.1/24", "gw": "192.168.0.254/24"}]}, {"name": "s2", "image": "local/centos", "IPs": [{"dev": "eth0", "IP": "192.168.0.2/24"}, {"dev": "eth1", "IP": "192.168.1.2/24", "gw": "192.168.1.254/24"}]}]} ## test utils self.__utils = DockerContainerTestUtils(**arg) ## environment definition file self.__filename = "/tmp/env.yml" # make service stub script f = open(stub, "w") f.write("import sys\n") f.write("sys.path.append('/vagrant')\n") f.write("from dockerEE.service import EnvironmentEmulationService\n") f.write("service = EnvironmentEmulationService('localhost', 'vagrant', 'vagrant')\n") f.write("service.action()") f.close() # make env.yml f = open(self.__filename, "w") f.write("---\n") f.write("servers:\n") for p in self.__parameter["servers"]: f.write(" - name: " + p["name"] + "\n") f.write(" image: " + p["image"] + "\n") f.write(" IPs:\n") for n in p["IPs"]: f.write(" - dev: " + n["dev"] + "\n") f.write(" IP: " + n["IP"] + "\n") if "gw" in n: f.write(" gw: " + n["gw"] + "\n") f.close() ## test "python service.py start/stop" # @param self The object pointer def testStartStop(self): servers = [x["name"] for x in self.__parameter["servers"]] ret = self.__service.start(self.__filename, 10) self.assertTrue(self.__utils.checkContainerExist(servers)) for p in self.__parameter["servers"]: for n in p["IPs"]: ret = self.__interface.sudo("docker exec -i " + p["name"] + " ip addr show") self.assertTrue(re.search(r"inet " + n["IP"] + ".*" + n["dev"], ret.stdout)) if "gw" in n: ret = self.__interface.sudo("docker exec -i " + p["name"] + " ip route show") self.assertIn("default via " + n["gw"].split("/")[0] + " dev " + n["dev"], ret.stdout) self.__service.stop(10) self.assertTrue(self.__utils.checkContainerNotExist(servers)) ## test "python service.py status" # @param self The object pointer def testStatus(self): servers = [x["name"] for x in self.__parameter["servers"]] self.__service.start(self.__filename, 10) ret = self.__service.status() status = "servers\n" for p in self.__parameter["servers"]: status += "\t" + p["name"] + "\n" for n in p["IPs"]: status += "\t\t" + n["dev"] + " : " + n["IP"] if "gw" in n: status += " via " + n["gw"] + "\n" else: status += "\n" ret.stdout += "\n" self.assertIn(status, ret.stdout) self.__service.stop(10) ret = self.__service.status() self.assertEqual(ret.rc, 0) ## test "python service.py reload" # @param self The object pointer def testReload(self): servers = [x["name"] for x in self.__parameter["servers"]] self.__service.start(self.__filename, 10) for s in servers: self.__interface.sudo("docker exec -i " + s + " touch /tmp/hello_dockerEE") for s in servers: ret = self.__interface.sudo("docker exec -i " + s + " test -f /tmp/hello_dockerEE", True) self.assertEqual(ret.rc, 0) self.__service.reload(servers[1:]) ret = self.__interface.sudo("docker exec -i " + servers[0] + " test -f /tmp/hello_dockerEE", True) self.assertEqual(ret.rc, 0) ret = self.__interface.sudo("docker exec -i " + servers[1] + " test -f /tmp/hello_dockerEE", True) self.assertEqual(ret.rc, 1) for p in self.__parameter["servers"]: for n in p["IPs"]: ret = self.__interface.sudo("docker exec -i " + p["name"] + " ip addr show") self.assertTrue(re.search(r"inet " + n["IP"] + ".*" + n["dev"], ret.stdout)) if "gw" in n: ret = self.__interface.sudo("docker exec -i " + p["name"] + " ip route show") self.assertIn("default via " + n["gw"].split("/")[0] + " dev " + n["dev"], ret.stdout) self.__service.stop(10)
class TestServer(unittest.TestCase): ## init test case # @param self The object pointer def setUp(self): arg = {"host": "localhost", "user": "******", "password": "******"} ## remote interface self.__interface = RemoteInterfaceImpl(**arg) ## container manager self.__container_manager = ContainerManagerImpl(**arg) ## host OS manager self.__host_manager = HostManagerImpl(**arg) ## test utils self.__utils = DockerContainerTestUtils(**arg) ## test Server.__init__(self, container_manager, name) # @param self The object pointer def testInit(self): server = "s1" s1 = Server(self.__container_manager, server) self.assertTrue(self.__utils.checkContainerExist(server)) ## test Server.__del__(self) # @param self The object pointer def testDel(self): servers = ["s1", "s2"] s = [Server(self.__container_manager, _s) for _s in servers] self.assertTrue(self.__utils.checkContainerExist(servers)) del s[:] self.assertFalse(self.__utils.checkContainerExist(servers)) ## test Server.__del__(self) with IP # @param self The object pointer def testDestroyIP(self): server_info = [{"name": "s1", "ip": ip_interface(u"192.168.0.1/24")}, {"name": "s2", "ip": ip_interface(u"192.168.0.2/24")}] servers = [] for s in server_info: servers.append(Server(self.__container_manager, s["name"])) servers[-1].attachIP(self.__host_manager, "eth0", s["ip"]) self.assertTrue(self.__utils.checkContainerExist([s["name"] for s in server_info])) self.assertIn("br_192.168.0.0", self.__interface.sudo("ip addr show").stdout) del servers[0] self.assertIn("br_192.168.0.0", self.__interface.sudo("ip addr show").stdout) del servers[0] self.assertNotIn("br_192.168.0.0", self.__interface.sudo("ip addr show").stdout) ## test Server.getNetworkInfo(self) # @param self The object pointer def testGetNetworkInfo(self): network = [{"dev": "eth0", "IP": ip_interface(u"192.168.0.1/24"), "gw": None}, {"dev": "eth1", "IP": ip_interface(u"192.168.1.2/24"), "gw": ip_interface(u"192.168.1.254/24")}] s1 = Server(self.__container_manager, "s1") for n in network: if n["gw"] is not None: s1.attachIP(self.__host_manager, n["dev"], n["IP"], n["gw"]) else: s1.attachIP(self.__host_manager, n["dev"], n["IP"]) self.assertEqual(s1.getNetworkInfo(), network) ## test Server.command(command) # @param self The object pointer def testCommand(self): server = "s1" s1 = Server(self.__container_manager, server) ret = s1.command("uname -n") self.assertEqual(s1.command("uname -n").stdout, server) ## test Server.attachIP(host_manager, dev, IP, gw) # @param self The object pointer def testAttachIP(self): network = [{"dev": "eth0", "IP": ip_interface(u"192.168.0.1/24"), "gw": None}, {"dev": "eth1", "IP": ip_interface(u"192.168.1.2/24"), "gw": ip_interface(u"192.168.1.254/24")}] s1 = Server(self.__container_manager, "s1") for n in network: if n["gw"] is not None: s1.attachIP(self.__host_manager, n["dev"], n["IP"], n["gw"]) else: s1.attachIP(self.__host_manager, n["dev"], n["IP"]) ret = s1.command("ip addr show") for n in network: self.assertTrue(re.search(r"inet " + str(n["IP"]) + ".*" + n["dev"], ret.stdout)) ret = s1.command("ip route show") for n in network: if n["gw"] is not None: self.assertIn("default via " + str(n["gw"].ip) + " dev " + n["dev"], ret.stdout) ## test Server.reload(self) # @param self The object pointer def testReload(self): s1 = Server(self.__container_manager, "s1") ret = s1.command("touch /tmp/hello_dockerEE") self.assertEqual(ret.rc, 0) ret = s1.command("test -f /tmp/hello_dockerEE") self.assertEqual(ret.rc, 0) s1.reload(self.__container_manager, self.__host_manager) with self.assertRaises(RuntimeError): ret = s1.command("test -f /tmp/hello_dockerEE") ## test Server.reload(self, options) # @param self The object pointer def testReloadOptions(self): image = "centos:6" s1 = Server(self.__container_manager, "s1", source=image) s1.reload(self.__container_manager, self.__host_manager) self.assertIn(image, self.__interface.sudo("docker ps -a").stdout.splitlines()[1].split()) ## test Server.reload(self) with IP # @param self The object pointer def testReloadIP(self): network = [{"dev": "eth0", "IP": ip_interface(u"192.168.0.1/24"), "gw": None}, {"dev": "eth1", "IP": ip_interface(u"192.168.1.2/24"), "gw": ip_interface(u"192.168.1.254/24")}] s1 = Server(self.__container_manager, "s1") for n in network: if n["gw"] is not None: s1.attachIP(self.__host_manager, n["dev"], n["IP"], n["gw"]) else: s1.attachIP(self.__host_manager, n["dev"], n["IP"]) s1.reload(self.__container_manager, self.__host_manager) ret = s1.command("ip addr show") for n in network: self.assertTrue(re.search(r"inet " + str(n["IP"]) + ".*" + n["dev"], ret.stdout)) ret = s1.command("ip route show") for n in network: if n["gw"] is not None: self.assertIn("default via " + str(n["gw"].ip) + " dev " + n["dev"], ret.stdout)
class TestContainerManagerImpl(unittest.TestCase): ## init test case # @param self The object pointer def setUp(self): arg = {"host": "localhost", "user": "******", "password": "******"} ## remote interface self.__interface = RemoteInterfaceImpl(**arg) ## container_manager self.__manager = ContainerManagerImpl(**arg) ## test utils self.__utils = DockerContainerTestUtils(**arg) ## test ContainerManagerImpl.create(name) # @param self The object pointer def testCreate(self): container = "c1" c = self.__manager.create(container) self.assertTrue(self.__utils.checkContainerExist(container)) ## test ContainerManagerImpl.create(name. privilege) # @param self The object pointer def testCreateWithPrivilege(self): container = "c1" c = self.__manager.create(container, privilege=["NET_ADMIN", "SYS_ADMIN"]) ret = self.__interface.sudo("docker exec -i " + container + " umount /etc/hosts") self.assertEqual(ret.rc, 0) ## test ContainerManagerImpl.create(name, hosts) # @param self The object pointer def testCreateWithHosts(self): container = "c1" hosts = [{"name": "c1", "IP": "1.0.1.10"}, {"name": "c2", "IP": "1.0.1.11"}] c = self.__manager.create(container, hosts=hosts) ret = self.__interface.sudo("docker exec -i " + container + " cat /etc/hosts") container_hosts = ret.stdout.splitlines()[-len(hosts):] for i in range(len(hosts)): container_host = container_hosts[i].split() host = hosts[i] self.assertEqual(container_host[1], host["name"]) self.assertEqual(container_host[0], host["IP"]) ## test ContainerManagerImpl.create(name, image) # @param self The object pointer def testCreateWithImage(self): container = "c1" image = "centos:6" c = self.__manager.create(container, image=image) ret = self.__interface.sudo("docker ps -a") lines = ret.stdout.splitlines() self.assertIn(image, lines[1].split()) ## test ContainerManagerImpl.destroyContainerImpl(container) # @param self The object pointer def testDestroy(self): container = "c1" c = self.__manager.create(container) self.assertTrue(self.__utils.checkContainerExist(container)) del c self.assertTrue(self.__utils.checkContainerNotExist(container)) ## test ContainerManagerImpl.command(container, command) # @param self The object pointer def testCommand(self): container = "c1" c = self.__manager.create(container) ret = c.command("uname -n") self.assertEqual(ret.stdout, container) ## test ContainerManagerImpl.attachIP(container, segment, dev, IP, gw) # @param self The object pointer def testAttachIP(self): bridge = "br1" self.__interface.sudo("brctl addbr " + bridge) self.__interface.sudo("ip link set " + bridge + " up") container = "c1" c = self.__manager.create(container) ip1 = ip_interface(u"192.168.0.1/24") dev1 = "eth0" c.attachIP(bridge, dev1, ip1) ret = c.command("ip addr show") self.assertTrue(re.search(r"inet " + str(ip1) + ".*" + dev1, ret.stdout)) ip2 = ip_interface(u"192.168.1.1/24") dev2 = "eth1" gw = ip_interface(u"192.168.1.254/24") c.attachIP(bridge, dev2, ip2, gw) ret = c.command("ip addr show") self.assertTrue(re.search(r"inet " + str(ip2) + ".*" + dev2, ret.stdout)) ret = c.command("ip route show") self.assertIn("default via " + str(gw.ip) + " dev " + dev2, ret.stdout) self.__interface.sudo("ip link set " + bridge + " down") self.__interface.sudo("brctl delbr " + bridge) ## test ContainerManagerImpl.__init__(host, user, password) fails because docker service is not running # @param self The object pointer def testFailInit(self): self.__interface.sudo("service docker stop") with self.assertRaises(RuntimeError): self.setUp() self.__interface.sudo("service docker start") ## test ContainerManagerImpl.create(name) fails because docker service is not running # @param self The object pointer def testFailCreate(self): self.__interface.sudo("service docker stop") with self.assertRaises(RuntimeError): self.__manager.create("c1") self.__interface.sudo("service docker start") ## test ContainerManagerImpl.command(container, command) fails because the command does not exist # @param self The object pointer def testFailCommand(self): container = "c1" c = self.__manager.create(container) with self.assertRaises(RuntimeError): c.command("fail") ## test ContainerManagerImpl.attachIP(container, segment, dev, IP) fails bacause the same dev is already attached # @param self The object pointer def testFailAttachIP(self): bridge = "br1" self.__interface.sudo("brctl addbr " + bridge) self.__interface.sudo("ip link set " + bridge + " up") container = "c1" c = self.__manager.create(container) ip = ip_interface(u"192.168.0.1/24") dev = "eth0" c.attachIP(bridge, dev, ip) with self.assertRaises(RuntimeError): c.attachIP(bridge, dev, ip) self.__interface.sudo("ip link set " + bridge + " down") self.__interface.sudo("brctl delbr " + bridge)