def setUp(self):
self.lg.info('Choose one random node of list of running nodes.')
self.node_id = self.get_random_node()
if self.node_id is None:
self.lg.info(' No node found')
return
self.node = {}
for node in self.nodes:
if node['id'] == self.node_id:
self.g8os_ip = node['ip']
self.node = node
break
self.g8core = Client(self.g8os_ip)
self.root_url = "https://hub.gig.tech/deboeckj/flist-lede-17.01.0-r3205-59508e3-x86-64-generic-rootfs.flist"
self.storage = "ardb://hub.gig.tech:16379"
self.container_name = self.rand_str()
self.hostname = self.rand_str()
self.process_body = {'name': 'yes'}
self.container_body = {
"name": self.container_name,
"hostname": self.hostname,
"flist": self.root_url,
"hostNetworking": False,
"initProcesses": [],
"filesystems": [],
"ports": [],
"storage": self.storage
}
def setUp(self):
self.lg.info('Choose one random node of list of running nodes.')
self.node_id = self.get_random_node()
if self.node_id is None:
self.lg.info(' No node found')
return
self.node = {}
for node in self.nodes:
if node['id'] == self.node_id:
self.g8os_ip = node['ip']
self.node = node
break
self.python_client = Client(self.g8os_ip)
def setUp(self):
super(TestZerotiersAPI, self).setUp()
self.lg.info('Get random nodid (N0)')
self.nodeid = self.get_random_node()
pyclient_ip = [x['ip'] for x in self.nodes
if x['id'] == self.nodeid][0]
self.pyclient = Client(pyclient_ip)
self.lg.info('Join zerotier network (ZT0)')
self.nwid = self.create_zerotier_network()
self.body = {"nwid": self.nwid}
self.zerotier_api.post_nodes_zerotiers(self.nodeid, self.body)
for _ in range(50):
response = self.zerotier_api.get_nodes_zerotiers_zerotierid(
self.nodeid, self.nwid)
if response.status_code == 200:
if response.json()['status'] == 'OK':
break
else:
time.sleep(3)
else:
self.lg.info('can\'t join zerotier network {}'.format(
self.nwid))
else:
self.lg.info('zerotier network status is {}'.format(
response.json()['status']))
def setUp(self):
super(TestStorageclustersAPI, self).setUp()
self.nodeid = self.get_random_node()
pyclient_ip = [x['ip'] for x in self.nodes
if x['id'] == self.nodeid][0]
self.pyclient = Client(pyclient_ip)
if self._testMethodName != 'test003_deploy_new_storagecluster':
self.lg.info('Deploy new storage cluster (SC0)')
free_disks = self.pyclient.getFreeDisks()
if free_disks == []:
self.skipTest('no free disks to create storagecluster')
self.label = self.rand_str()
self.servers = randint(1, len(free_disks))
self.drivetype = 'ssd'
self.slaveNodes = False
self.body = {
"label": self.label,
"servers": self.servers,
"driveType": self.drivetype,
"slaveNodes": self.slaveNodes,
"nodes": [self.nodeid]
}
self.storageclusters_api.post_storageclusters(self.body)
for _ in range(60):
response = self.storageclusters_api.get_storageclusters_label(
self.label)
if response.status_code == 200:
if response.json()['status'] == 'ready':
break
else:
time.sleep(3)
else:
time.sleep(10)
else:
self.lg.error(
'storagecluster status is not ready after 180 sec')
def setUp(self):
super(TestVmsAPI, self).setUp()
self.lg.info('Get random nodid (N0)')
self.nodeid = self.get_random_node()
nodeip = [x['ip'] for x in self.nodes if x['id'] == self.nodeid][0]
self.pyclient = Client(nodeip)
storageclusters = self.storageclusters_api.get_storageclusters()
if storageclusters.json() == []:
self.storagecluster = self.create_sotragecluster()['label']
else:
self.storagecluster = storageclusters.json()[0]
vdisks = self.vdisks_apis.get_vdisks()
vdisks = [
x for x in vdisks.json()
if (x['id'] == 'ubuntu-test-vdisk'
and x['storageCluster'] == self.storagecluster)
]
if vdisks == []:
self.vdisk = self.create_boot_vdisk(self.storagecluster)
else:
self.vdisk = vdisks[0]
def setUp(self):
super(TestBridgesAPI, self).setUp()
self.lg.info('Get random nodid (N0)')
self.nodeid = self.get_random_node()
pyclient_ip = [x['ip'] for x in self.nodes if x['id'] == self.nodeid][0]
self.pyclient = Client(pyclient_ip)
self.lg.info('Create bridge (B0) on node (N0)')
self.name = self.rand_str()
self.hwaddr = self.randomMAC()
self.networkMode = "none"
self.nat = False
self.settings = {}
self.body = {"name":self.name,
"hwaddr":self.hwaddr,
"networkMode":self.networkMode,
"nat":self.nat,
"setting":self.settings}
self.bridges_api.post_nodes_bridges(self.nodeid, self.body)
time.sleep(3)
def test011_post_nodes_vms_vmid_migrate(self):
""" GAT-077
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Migrate virtual machine (VM0) to another node, should succeed with 204.
#. Get virtual machine (VM0), virtual machine (VM0) status should be migrating.
"""
if len(self.nodes) < 2:
self.skipTest('need at least 2 nodes')
self.lg.info(
'Migrate virtual machine (VM0) to another node, should succeed with 204'
)
node_2 = self.get_random_node(except_node=self.nodeid)
body = {"nodeid": node_2}
response = self.vms_api.post_nodes_vms_vmid_migrate(
self.nodeid, self.vm_id, body)
self.assertEqual(response.status_code, 204)
for _ in range(15):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, self.vm_id)
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'running':
break
else:
time.sleep(1)
response = self.vms_api.get_nodes_vms_vmid(node_2, self.vm_id)
self.assertEqual(response.status_code, 200)
pyclient_ip = [x['ip'] for x in self.nodes if x['id'] == node_2]
self.assertNotEqual(pyclient_ip, [])
pyclient = Client(pyclient_ip)
vms = pyclient.client.kvm.list()
self.assertIn(self.vm_id, [x['name'] for x in vms])
class TestcontaineridAPI(TestcasesBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def setUp(self):
self.lg.info('Choose one random node of list of running nodes.')
self.node_id = self.get_random_node()
if self.node_id is None:
self.lg.info(' No node found')
return
self.node = {}
for node in self.nodes:
if node['id'] == self.node_id:
self.g8os_ip = node['ip']
self.node = node
break
self.g8core = Client(self.g8os_ip)
self.root_url = "https://hub.gig.tech/deboeckj/flist-lede-17.01.0-r3205-59508e3-x86-64-generic-rootfs.flist"
self.storage = "ardb://hub.gig.tech:16379"
self.container_name = self.rand_str()
self.hostname = self.rand_str()
self.process_body = {'name': 'yes'}
self.container_body = {
"name": self.container_name,
"hostname": self.hostname,
"flist": self.root_url,
"hostNetworking": False,
"initProcesses": [],
"filesystems": [],
"ports": [],
"storage": self.storage
}
def tearDown(self):
self.lg.info('TearDown:delete all created container ')
for container in self.createdcontainer:
self.containers_api.delete_containers_containerid(
container['node'], container['container'])
def test001_check_coonection_with_False_hostNetworking(self):
""" GAT-082
*Check container internet connection with false hostNetworking options *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Create container with false hostNetworking.
#. Try to connect to internet from created container ,Should fail.
"""
self.lg.info('Send post nodes/{nodeid}/containers api request.')
response = self.containers_api.post_containers(
node_id=self.node_id, body=self.container_body)
self.assertEqual(response.status_code, 201)
self.lg.info('Make sure it running .')
self.assertTrue(
self.wait_for_container_status(
"running",
self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name))
self.createdcontainer.append({
"node": self.node_id,
"container": self.container_name
})
self.lg.info(
"Try to connect to internet from created container ,Should fail.")
container = self.g8core.get_container_client(self.container_name)
self.assertTrue(container)
response = container.bash('ping -c 5 google.com').get()
self.assertEqual(response.state, 'ERROR')
def test002_check_coonection_with_True_hostNetworking(self):
""" GAT-083
*Check container internet connection with true hostNetworking options *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Create container with True hostNetworking.
#. Try to connect to internet from created container ,Should succeed.
"""
self.container_body['hostNetworking'] = True
self.lg.info('Send post nodes/{nodeid}/containers api request.')
response = self.containers_api.post_containers(
node_id=self.node_id, body=self.container_body)
self.assertEqual(response.status_code, 201)
self.lg.info('Make sure it is running .')
self.assertTrue(
self.wait_for_container_status(
"running",
self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name))
self.createdcontainer.append({
"node": self.node_id,
"container": self.container_name
})
self.lg.info(
"Try to connect to internet from created container ,Should succeed."
)
container = self.g8core.get_container_client(self.container_name)
self.assertTrue(container)
response = container.bash('ping -c 5 google.com').get()
self.assertEqual(response.state, 'SUCCESS')
self.assertNotIn("unreachable", response.stdout)
def test003_create_container_with_init_process(self):
""" GAT-084
*Check that container created with init process *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Create container with initProcess.
#. Check that container created with init process.
"""
self.container_body[
'flist'] = "https://hub.gig.tech/dina_magdy/initprocess.flist"
## flist which have script which print environment varaibles and print stdin
Environmentvaraible = "MYVAR=%s" % self.rand_str()
stdin = self.rand_str()
self.container_body['initProcesses'] = [{
"name":
"sh",
"pwd":
"/",
"args": ["sbin/process_init"],
"environment": ["%s" % Environmentvaraible],
"stdin":
"%s" % stdin
}]
self.lg.info('Send post nodes/{nodeid}/containers api request.')
response = self.containers_api.post_containers(
node_id=self.node_id, body=self.container_body)
self.assertEqual(response.status_code, 201)
self.lg.info('Make sure it running')
self.assertTrue(
self.wait_for_container_status(
"running",
self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name))
self.createdcontainer.append({
"node": self.node_id,
"container": self.container_name
})
self.lg.info("Check that container created with init process.")
container = self.g8core.get_container_client(self.container_name)
response = container.bash("ls |grep out.text").get()
self.assertEqual(response.state, "SUCCESS")
response = container.bash("cat out.text | grep %s" % stdin).get()
self.assertEqual(response.state, "SUCCESS",
"init processes didn't get stdin correctly")
response = container.bash("cat out.text | grep %s" %
Environmentvaraible).get()
self.assertEqual(response.state, "SUCCESS",
"init processes didn't get Env varaible correctly")
def test004_create_containers_with_different_flists(self):
""" GAT-085
*create contaner with different flists *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random flist .
#. Create container with this flist, Should succeed.
#. Make sure it created with required values, should succeed.
#. Make sure that created container is running,should succeed.
#. Check that container created on node, should succeed
"""
flistslist = [
"ovs.flist", "ubuntu1604.flist", "grid-api-flistbuild.flist",
"cloud-init-server-master.flist"
]
flist = random.choice(flistslist)
self.container_body[
'flist'] = "https://hub.gig.tech/gig-official-apps/%s" % flist
self.lg.info('Send post nodes/{nodeid}/containers api request.')
response = self.containers_api.post_containers(
node_id=self.node_id, body=self.container_body)
self.assertEqual(response.status_code, 201)
self.lg.info(
'Make sure it created with required values and running, should succeed.'
)
self.assertTrue(
self.wait_for_container_status(
"running",
self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name))
self.createdcontainer.append({
"node": self.node_id,
"container": self.container_name
})
response = self.containers_api.get_containers_containerid(
self.node_id, self.container_name)
self.assertEqual(response.status_code, 200)
response_data = response.json()
for key in response_data.keys():
if key == 'initprocesses':
self.assertEqual(response_data[key],
self.container_body['initProcesses'])
continue
if key in self.container_body.keys():
self.assertEqual(response_data[key], self.container_body[key])
self.lg.info("check that container created on node, should succeed")
self.assertTrue(self.g8core.client.container.find(self.container_name))
@unittest.skip("https://github.com/g8os/core0/issues/228")
def test005_Check_container_access_to_host_dev(self):
""" GAT-086
*Make sure that container doesn't have access to host dev files *
**Test Scenario:**
#. Create container, Should succeed.
#. Make sure that created container is running,should succeed.
#. Check that container doesn't has access to host dev files .
"""
self.lg.info('Send post nodes/{nodeid}/containers api request.')
response = self.containers_api.post_containers(
node_id=self.node_id, body=self.container_body)
self.assertEqual(response.status_code, 201)
self.lg.info(
'Make sure it created with required values and running, should succeed.'
)
self.assertTrue(
self.wait_for_container_status(
"running",
self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name))
self.createdcontainer.append({
"node": self.node_id,
"container": self.container_name
})
self.lg.info(
"Check that container doesn't has access to host dev files .")
container = self.g8core.get_container_client(self.container_name)
response = container.bash("ls -alh").get().stdout
for line in response.splitlines():
if "dev" in line:
self.assertNotIn('w', line)
class TestcontaineridAPI(TestcasesBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def setUp(self):
self.lg.info('Choose one random node of list of running nodes.')
self.node_id = self.get_random_node()
if self.node_id is None:
self.lg.info(' No node found')
return
self.node = {}
for node in self.nodes:
if node['id'] == self.node_id:
self.g8os_ip = node['ip']
self.node = node
break
self.g8core = Client(self.g8os_ip)
self.root_url = "https://hub.gig.tech/deboeckj/flist-lede-17.01.0-r3205-59508e3-x86-64-generic-rootfs.flist"
self.storage = "ardb://hub.gig.tech:16379"
self.container_name = self.rand_str()
self.hostname = self.rand_str()
self.process_body = {'name': 'yes'}
self.container_body = {"name": self.container_name, "hostname": self.hostname, "flist": self.root_url,
"hostNetworking": False, "initProcesses": [], "filesystems": [],
"ports": [], "storage": self.storage
}
def tearDown(self):
self.lg.info('TearDown:delete all created container ')
for container in self.createdcontainer:
self.containers_api.delete_containers_containerid(container['node'],
container['container'])
def test001_list_containers(self):
""" GAT-022
*GET:/node/{nodeid}/containers Expected: List of all running containers *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Send get nodes/{nodeid}/containers api request.
#. Compare results with golden value.
"""
containers_id = []
Running_containers_list= []
self.lg.info('Send get nodes/{nodeid}/containers api request.')
response = self.containers_api.get_containers(self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('Compare results with golden value.')
containers_list = response.json()
for container in containers_list:
if container['status']=="running":
Running_containers_list.append(container)
golden_value_list = self.g8core.client.container.list()
self.assertEqual(len(Running_containers_list), len(golden_value_list))
for container in Running_containers_list:
if container['name']:
self.assertTrue(self.g8core.client.container.find(container['name']),'container %s not in golden value '%container['name'])
def test002_create_containers(self):
""" GAT-023
*post:/node/{nodeid}/containers Expected: create container then delete it *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Send post nodes/{nodeid}/containers api request.
#. Make sure it created with required values, should succeed.
#. Delete ctreated container,should succeed
#. make sure that it deleted .
"""
self.lg.info('Send post nodes/{nodeid}/containers api request.')
response = self.containers_api.post_containers(node_id=self.node_id, body=self.container_body)
self.assertEqual(response.status_code, 201)
self.lg.info('Make sure it created with required values, should succeed.')
self.assertEqual(response.headers['Location'], "/nodes/%s/containers/%s" % (self.node_id, self.container_name))
self.assertTrue(self.wait_for_container_status("running", self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name))
response = self.containers_api.get_containers_containerid(self.node_id, self.container_name)
self.assertEqual(response.status_code, 200)
response_data = response.json()
for key in response_data.keys():
if key == 'initprocesses':
self.assertEqual(response_data[key], self.container_body['initProcesses'])
continue
if key in self.container_body.keys():
self.assertEqual(response_data[key], self.container_body[key])
self.lg.info('delete created container')
response = self.containers_api.delete_containers_containerid(self.node_id, self.container_name)
self.assertEqual(response.status_code, 204)
self.lg.info('Make sure that it deleted ')
response = self.containers_api.get_containers(self.node_id)
containers_list = response.json()
self.assertFalse(any(container['name'] == self.container_name for container in containers_list))
self.assertFalse(self.g8core.client.container.find(self.container_name),'container %s still exist in g8os '%self.container_name)
def test003_get_container_details(self):
""" GAT-024
*get:/node/{nodeid}/containers/containerid Expected: get container details *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Get:/node/{nodeid}/containers/containerid
#. Compare results with golden value.
"""
self.lg.info('Choose random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Send get nodes/{nodeid}/containers/containerid api request.')
response = self.containers_api.get_containers_containerid(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
data = response.json()
self.lg.info(' Compare results with golden value.')
golden_value = self.g8core.get_container_info(container_name)
self.assertTrue(golden_value)
for key in data.keys():
if key in golden_value.keys():
self.assertEqual(data[key], golden_value[key])
def test004_stop_and_start_container(self):
""" GAT-025
*post:/node/{nodeid}/containers/containerid/start Expected: get container details *
**Test Scenario:**
#. Create container.
#. post:/node/{nodeid}/containers/containerid/stop.
#. Check that container stpoed .
#. Post:/node/{nodeid}/containers/containerid/start.
#. Check that container running .
"""
self.lg.info('Create container ')
response = self.containers_api.post_containers(self.node_id, self.container_body)
self.assertEqual(response.status_code, 201)
self.createdcontainer.append({"node": self.node_id, "container": self.container_name})
container_id = self.wait_for_container_status("running", self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name)
self.assertTrue(container_id)
self.lg.info('post:/node/{nodeid}/containers/containerid/stop.')
response = self.containers_api.post_containers_containerid_stop(self.node_id, self.container_name)
self.assertEqual(response.status_code, 204)
self.lg.info('Check that container stoped.')
self.assertTrue(self.wait_for_container_status("halted", self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name))
self.assertTrue(self.g8core.wait_on_container_update(container_id, 60, True))
self.lg.info('post:/node/{nodeid}/containers/containerid/start.')
response = self.containers_api.post_containers_containerid_start(self.node_id, self.container_name)
self.assertEqual(response.status_code, 201)
self.lg.info('Check that container running.')
self.assertTrue(self.wait_for_container_status("running", self.containers_api.get_containers_containerid,
node_id=self.node_id,
container_id=self.container_name))
self.assertTrue(self.g8core.wait_on_container_update(self.container_name, 60, False))
def test005_get_running_jobs(self):
""" GAT-026
*get:/node/{nodeid}/containers/containerid/jobs Expected: get container details *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Get:/node/{nodeid}/containers/containerid/jobs
#. Compare results with golden value.
"""
self.lg.info('Choose random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Send get nodes/{nodeid}/containers/containerid/jobs api request.')
response = self.containers_api.get_containers_containerid_jobs(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
self.lg.info('Compare results with golden value.')
running_jobs_list = response.json()
golden_values = self.g8core.get_container_job_list(container_name)
api_jobs = set([(job['id'], job['startTime'])for job in running_jobs_list])
self.assertEqual(len(golden_values.difference(api_jobs)), 1)
def test006_kill_all_running_jobs(self):
""" GAT-027
*get:/node/{nodeid}/containers/containerid/jobs Expected: get container details*
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. delete :/node/{nodeid}/containers/containerid/jobs.
#. Check that all jobs in this container killed.
#. Compare results with golden value.
"""
self.lg.info('Choose random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Spawn multiple jobs.')
for i in range(0, 3):
response = self.containers_api.post_containers_containerid_processes(self.node_id, container_name,
self.process_body)
self.assertEqual(response.status_code, 202)
job_id = response.headers['Location'].split('/')[6]
self.assertTrue(self.g8core.wait_on_container_job_update(container_name, job_id, 15, False))
self.lg.info('Send delete nodes/{nodeid}/containers/containerid/jobs api request.')
response = self.containers_api.delete_containers_containerid_jobs(self.node_id, container_name)
self.assertEqual(response.status_code, 204)
time.sleep(5)
self.lg.info('Check that all jobs in this container killed ')
response = self.containers_api.get_containers_containerid_jobs(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
jobs_list = response.json()
self.assertEqual(len(jobs_list), 1)
self.assertEqual(len(self.g8core.get_container_job_list(container_name)), 1)
self.lg.info('Compare results with golden value.')
def test007_get_job_in_container_details(self):
""" GAT-028
*get:/node/{nodeid}/containers/containerid/jobs/jobid Expected: get container details *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Choose one random job of list of running jobs in container.
#. Send get nodes/{nodeid}/containers/containerid/jobs/jobid api request
#. Compare results with golden value.
"""
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info(' spawn job in container ')
response = self.containers_api.post_containers_containerid_processes(self.node_id, container_name,
self.process_body)
self.assertEqual(response.status_code, 202)
job_id = response.headers['Location'].split('/')[6]
self.assertTrue(self.g8core.wait_on_container_job_update(container_name, job_id, 15, False))
self.lg.info('Send get nodes/{nodeid}/containers/containerid/jobs/jobid api request.')
response = self.containers_api.get_containers_containerid_jobs_jobid(self.node_id, container_name, job_id)
self.assertEqual(response.status_code, 200)
job_details = response.json()
self.lg.info('Compare results with golden value.')
container_id = int(list(self.g8core.client.container.find(container_name).keys())[0])
container = self.g8core.client.container.client(container_id)
golden_value = container.job.list(job_id)[0]
self.assertEqual(golden_value['cmd']['command'], job_details['name'])
self.assertEqual(golden_value['cmd']['id'], job_details['id'])
self.assertEqual(golden_value['starttime'], job_details['startTime'])
response = self.containers_api.delete_containers_containerid_jobs_jobid(self.node_id, container_name, job_id)
self.assertEqual(response.status_code, 204)
self.assertTrue(self.g8core.wait_on_container_job_update(container_name, job_id, 15, True))
def test008_post_signal_job_in_container_details(self):
""" GAT-029
*get:/node/{nodeid}/containers/containerid/jobs/jobid Expected: get container details *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Choose one random job of list of running jobs in container.
#. Send post nodes/{nodeid}/containers/containerid/jobs/jobid api request, should succeed
"""
signal = random.randint(1, 30)
body = {'signal': signal}
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info(' spawn job in container ')
response = self.containers_api.post_containers_containerid_processes(self.node_id, container_name,
self.process_body)
self.assertEqual(response.status_code, 202)
job_id = response.headers['Location'].split('/')[6]
self.lg.info('Send post nodes/{nodeid}/containers/containerid/jobs/jobid api request.')
response = self.containers_api.post_containers_containerid_jobs_jobid(self.node_id, container_name,
job_id, body)
self.assertEqual(response.status_code, 204)
def test009_kill_specific_job(self):
""" GAT-030
*get:/node/{nodeid}/containers/containerid/jobs/jobid Expected: get container details *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Choose one random job of list of running jobs in container.
#. Send delete nodes/{nodeid}/containers/containerid/jobs/jobid api request, should succeed
#. Check that job delted from running jobs list.
#. Check that job delted from client list.
"""
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info(' spawn job in container ')
response = self.containers_api.post_containers_containerid_processes(self.node_id, container_name,
self.process_body)
self.assertEqual(response.status_code, 202)
job_id = response.headers['Location'].split('/')[6]
self.assertTrue(self.g8core.wait_on_container_job_update(container_name,
job_id, 60, False))
self.lg.info('Send delete nodes/{nodeid}/containers/containerid/jobs/jobid api request.')
response = self.containers_api.delete_containers_containerid_jobs_jobid(self.node_id, container_name, job_id)
self.assertEqual(response.status_code, 204)
self.lg.info('Check that job delted from running jobs list.')
response = self.containers_api.get_containers_containerid_jobs(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
running_jobs_list = response.json()
for job in running_jobs_list:
self.assertNotEqual(job['id'], job_id)
self.lg.info('Check that job delted from client list.')
self.assertTrue(self.g8core.wait_on_container_job_update(container_name,
job_id, 60, True))
def test010_post_ping_to_container(self):
""" GAT-031
*get:/node/{nodeid}/containers/containerid/ping *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Send post nodes/{nodeid}/containers/containerid/post request.
"""
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Send post nodes/{nodeid}/containers/containerid/ping api request.')
response = self.containers_api.post_containers_containerid_ping(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
def test011_get_state_of_container(self):
""" GAT-032
*get:/node/{nodeid}/containers/containerid/state *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Send get nodes/{nodeid}/containers/containerid/state request.
#. Compare results with golden value.
"""
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Send GET nodes/{nodeid}/containers/containerid/state api request.')
response = self.containers_api.get_containers_containerid_state(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
self.lg.info(' Compare results with golden value.')
container_state = response.json()
container_id = int(list(self.g8core.client.container.find(container_name).keys())[0])
golden_value = self.g8core.client.container.list()[str(container_id)]
self.assertAlmostEqual(golden_value['rss'], container_state['rss'], delta=1000000)
self.assertEqual(golden_value['swap'], container_state['swap'])
self.assertAlmostEqual(golden_value['vms'], container_state['vms'], delta=10000000)
def test012_get_info_of_container_os(self):
""" GAT-033
*get:/node/{nodeid}/containers/containerid/info *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Send get nodes/{nodeid}/containers/containerid/info request.
#. Compare results with golden value.
"""
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Send post nodes/{nodeid}/containers/containerid/state api request.')
response = self.containers_api.get_containers_containerid_info(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
self.lg.info(' Compare results with golden value.')
container_info = response.json()
container_id = int(list(self.g8core.client.container.find(container_name).keys())[0])
container = self.g8core.client.container.client(container_id)
golden_value = container.info.os()
self.assertAlmostEqual(golden_value.pop('uptime'), container_info.pop('uptime'), delta=50)
for key in container_info:
if key not in golden_value:
self.assertEqual(golden_value[key], container_info[key])
def test013_get_running_processes_in_container(self):
""" GAT-034
*get:/node/{nodeid}/containers/containerid/processes *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Send get nodes/{nodeid}/containers/containerid/processes request.
#. Compare results with golden value.
"""
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Send post nodes/{nodeid}/containers/containerid/state api request.')
response = self.containers_api.get_containers_containerid_processes(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
processes = response.json()
container_id = int(list(self.g8core.client.container.find(container_name).keys())[0])
container = self.g8core.client.container.client(container_id)
golden_values = container.process.list()
self.lg.info(' Compare results with golden value.')
processes.sort(key=lambda d: d['pid'])
golden_values.sort(key=lambda d: d['pid'])
for i, p in enumerate(processes):
self.assertEqual(p['cmdline'], golden_values[i]['cmdline'])
self.assertEqual(p['pid'], golden_values[i]['pid'])
self.assertAlmostEqual(p['rss'], golden_values[i]['rss'], delta=1000000)
self.assertEqual(p['swap'], golden_values[i]['swap'])
self.assertAlmostEqual(p['vms'], golden_values[i]['vms'], delta=10000000)
def test014_post_create_new_processes_in_container(self):
""" GAT-035
*post:/node/{nodeid}/containers/containerid/processes *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Send post nodes/{nodeid}/containers/containerid/processes request.\
#. Check that created process added to process list.
#. Compare results with golden value.
"""
process_name = self.process_body['name']
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Send post nodes/{nodeid}/containers/containerid/processes api request.')
response = self.containers_api.post_containers_containerid_processes(self.node_id, container_name,
self.process_body)
self.assertEqual(response.status_code, 202)
job_id = response.headers['Location'].split('/')[6]
self.assertTrue(self.g8core.wait_on_container_job_update(container_name, job_id, 15, False))
self.lg.info('Check that created process added to process list.')
time.sleep(7)
response = self.containers_api.get_containers_containerid_processes(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
processes = [p['cmdline'] for p in response.json()]
self.assertIn(process_name, processes)
self.lg.info(' Compare results with golden value.')
container_id = int(list(self.g8core.client.container.find(container_name).keys())[0])
container = self.g8core.client.container.client(container_id)
golden_values = [p['cmdline'] for p in container.process.list()]
self.assertIn(process_name, golden_values)
def test015_get_process_details_in_container(self):
""" GAT-036
*post:/node/{nodeid}/containers/containerid/processes/processid *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Choose one random process of list of process.
#. Send get nodes/{nodeid}/containers/containerid/processes/processid request.
#. Compare results with golden value.
"""
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Choose one random process of list of processes')
response = self.containers_api.post_containers_containerid_processes(self.node_id, container_name,
self.process_body)
self.assertEqual(response.status_code, 202)
job_id = response.headers['Location'].split('/')[6]
self.assertTrue(self.g8core.wait_on_container_job_update(container_name, job_id, 15, False))
response = self.containers_api.get_containers_containerid_processes(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
processes_list = response.json()
process_id = None
while not process_id or process_id == 1:
random_number = random.randint(0, len(processes_list)-1)
process_id = processes_list[random_number]['pid']
self.lg.info('Send get nodes/{nodeid}/containers/containerid/processes/processid api request.')
response = self.containers_api.get_containers_containerid_processes_processid(self.node_id, container_name,
str(process_id))
self.assertEqual(response.status_code, 200)
process = response.json()
container_id = int(list(self.g8core.client.container.find(container_name).keys())[0])
container = self.g8core.client.container.client(container_id)
golden_value = container.process.list(process_id)[0]
self.lg.info(' Compare results with golden value.')
self.assertAlmostEqual(golden_value.pop('rss'), process.pop('rss'), delta=1000000)
self.assertAlmostEqual(golden_value.pop('vms'), process.pop('vms'), delta=10000000)
for key in process:
if key == 'cpu':
continue
if key in golden_value.keys():
self.assertEqual(golden_value[key], process[key])
def test016_delete_process_in_container(self):
""" GAT-037
*post:/node/{nodeid}/containers/containerid/processes/processid *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Choose one random process of list of process.
#. Send delete nodes/{nodeid}/containers/containerid/processes/processid request.
#. Check that created process deleted from process list.
#. Compare results with golden value.
"""
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
self.lg.info('Choose one random process of list of processes')
response = self.containers_api.post_containers_containerid_processes(self.node_id, container_name,
self.process_body)
self.assertEqual(response.status_code, 202)
time.sleep(10)
response = self.containers_api.get_containers_containerid_processes(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
processes_list = response.json()
process_id = None
while not process_id or process_id == 1:
random_number = random.randint(0, len(processes_list)-1)
process_id = processes_list[random_number]['pid']
self.lg.info('Send delete nodes/{nodeid}/containers/containerid/processes/processid api request.')
response = self.containers_api.delete_containers_containerid_processes_processid(self.node_id, container_name,
str(process_id))
self.assertEqual(response.status_code, 204)
self.lg.info('Check that created process deleted from process list.')
response = self.containers_api.get_containers_containerid_processes(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
processes_list = response.json()
for process in processes_list:
self.assertNotEqual(process['pid'], process_id)
self.lg.info(' Compare results with golden value.')
container=self.g8core.client.container.find(container_name)
self.assertTrue(container)
container_id = int(list(container.keys())[0])
container = self.g8core.client.container.client(container_id)
golden_value = container.process.list()
for process in golden_value:
self.assertNotEqual(process['pid'], process_id)
def test017_post_signal_to_process_in_container(self):
""" GAT-038
*get:/node/{nodeid}/containers/containerid/processes/processid Expected: get container details *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Choose one random conatainer of list of running containers.
#. Choose one random process of list of running processes in container.
#. Send post nodes/{nodeid}/containers/containerid/processes/process api request, should succeed
"""
signal = random.randint(1, 30)
body = {'signal': signal}
self.lg.info('Choose one random container of list of running nodes')
container_name = self.get_random_container(self.node_id)
self.assertTrue(container_name)
response = self.containers_api.post_containers_containerid_processes(self.node_id, container_name,
self.process_body)
self.assertEqual(response.status_code, 202)
self.lg.info('Choose one random process of list of processes')
response = self.containers_api.get_containers_containerid_processes(self.node_id, container_name)
self.assertEqual(response.status_code, 200)
processes_list = response.json()
process_id = None
while not process_id or process_id == 1:
random_number = random.randint(0, len(processes_list)-1)
process_id = processes_list[random_number]['pid']
self.lg.info('Send post nodes/{nodeid}/containers/containerid/processes/processid api request.')
response = self.containers_api.post_containers_containerid_processes_processid(self.node_id, container_name,
str(process_id), body)
self.assertEqual(response.status_code, 204)
def test018_upload_file_to_container(self):
""" GAT-039
*post:/node/{nodeid}/containers/containerid/filesystem *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Create new container .
#. post /node/{nodeid}/containers/containerid/filesystem api request should succeed.
#. Check that file exist in container .
#. Delete file from g8os node.
#. Delete file from container.
#. Check that file doesn\'t exist in container.
"""
self.lg.info('create container ')
response = self.containers_api.post_containers(node_id=self.node_id, body=self.container_body)
self.assertEqual(response.status_code, 201)
self.assertTrue(self.wait_for_container_status('running', self.containers_api.get_containers_containerid,
node_id=self.node_id, container_id=self.container_name))
self.createdcontainer.append({"node": self.node_id, "container": self.container_name})
self.lg.info('create file in g8os node ')
file_name = self.rand_str()
self.g8core.client.bash('touch %s.text'%file_name)
body = {"file": '/%s.text'%file_name}
params = {"path": "/%s.text"%file_name}
response = self.containers_api.post_containers_containerid_filesystem(node_id=self.node_id,
container_id=self.container_name,
body=body,
params=params)
self.assertTrue(response.status_code,201)
self.lg.info('Check that file exist in container ')
container=self.g8core.client.container.find(self.container_name)
self.assertTrue(container)
container_id = int(list(container.keys())[0])
container = self.g8core.client.container.client(container_id)
output = container.bash('ls | grep %s.text'%file_name).get().state
self.assertEqual(output, "SUCCESS")
self.lg.info('delete file from g8os node ')
self.g8core.client.bash('rm %s.text'%file_name)
self.lg.info('delete file from container ')
body = {"path": "/%s.text"%file_name}
response = self.containers_api.delete_containers_containerid_filesystem(node_id=self.node_id,
container_id=self.container_name,
body=body,
)
self.assertEqual(response.status_code,204)
self.lg.info('Check that file doesn\'t exist in container ')
container=self.g8core.client.container.find(self.container_name)
self.assertTrue(container)
container_id = int(list(container.keys())[0])
container = self.g8core.client.container.client(container_id)
output = container.bash('ls | grep %s.text'%file_name).get().state
self.assertNotEqual(output, "SUCCESS")
def test019_download_file_from_container(self):
""" GAT-040
*get:/node/{nodeid}/containers/containerid/filesystem *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Create new container .
#. Make new file in container .
#. Get /node/{nodeid}/containers/containerid/filesystem api request should succeed.
#. Check that file downloaded
#. Delete file from container,
"""
file_name = self.rand_str()
self.lg.info('create container ')
response = self.containers_api.post_containers(node_id=self.node_id, body=self.container_body)
self.assertEqual(response.status_code, 201)
self.assertTrue(self.wait_for_container_status('running', self.containers_api.get_containers_containerid,
node_id=self.node_id, container_id=self.container_name))
self.createdcontainer.append({"node": self.node_id, "container": self.container_name})
self.lg.info('create new file in container ')
container=self.g8core.client.container.find(self.container_name)
self.assertTrue(container)
container_id = int(list(container.keys())[0])
container = self.g8core.client.container.client(container_id)
output = container.bash('echo "test" >%s.text'%file_name).get().state
self.assertEqual(output, "SUCCESS")
self.lg.info('Get created file from container ')
params = {"path": "/%s.text"%file_name}
response = self.containers_api.get_containers_containerid_filesystem(node_id=self.node_id,
container_id=self.container_name,
params=params)
self.assertTrue(response.status_code, 201)
self.lg.info('Check that file downloaded')
self.assertTrue(response.text, "test")
self.lg.info('delete file from container ')
output = container.bash('rm %s.text'%file_name).get().state
self.assertEqual(output, "SUCCESS")
class TestVdisks(TestcasesBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.vdisks_apis = VDisksAPIs()
self.storageclusters_api = Storageclusters()
def setUp(self):
super(TestVdisks, self).setUp()
node = self.get_random_node()
pyclient_ip = [x['ip'] for x in self.nodes if x['id'] == node][0]
self.pyclient = Client(pyclient_ip)
free_disks = self.pyclient.getFreeDisks()
if free_disks == []:
self.skipTest('no free disks to create storagecluster')
storageclusters = self.storageclusters_api.get_storageclusters()
if storageclusters.json() == []:
self.lg.info('Deploy new storage cluster (SC0)')
sc_label = self.rand_str()
sc_servers = random.randint(1, len(free_disks))
sc_drivetype = 'ssd'
sc_slaveNodes = False
sc_nodes = [self.get_random_node()]
sc_body = {
"label": sc_label,
"servers": sc_servers,
"driveType": sc_drivetype,
"slaveNodes": sc_slaveNodes,
"nodes": sc_nodes
}
self.storageclusters_api.post_storageclusters(sc_body)
for _ in range(60):
response = self.storageclusters_api.get_storageclusters_label(
sc_label)
if response.status_code == 200:
if response.json()['status'] == 'ready':
break
else:
time.sleep(3)
else:
time.sleep(10)
else:
self.lg.error(
'storagecluster status is not ready after 180 sec')
else:
sc_label = storageclusters.json()[0]
self.lg.info('Create vdisk (VD0)')
self.vd_creation_time = time.time()
self.vdisk_id = self.rand_str()
self.size = random.randint(1, 50)
self.types = ['boot', 'db', 'cache', 'tmp']
self.type = random.choice(self.types)
self.block_size = random.randint(1, self.size) * 1024 * 1024
self.storagecluster = sc_label
self.readOnly = random.choice([False, True])
self.body = {
"id": self.vdisk_id,
"size": self.size,
"blocksize": self.block_size,
"type": self.type,
"storagecluster": self.storagecluster,
"readOnly": self.readOnly
}
self.vdisks_apis.post_vdisks(self.body)
def tearDown(self):
self.lg.info('Delete vdisk (VD0)')
self.vdisks_apis.delete_vdisks_vdiskid(self.vdisk_id)
super(TestVdisks, self).tearDown()
def test001_get_vdisk_details(self):
""" GAT-061
*GET:/vdisks/{vdiskid}*
**Test Scenario:**
#. Create vdisk (VD0).
#. Get vdisk (VD0), should succeed with 200.
#. Get nonexisting vdisk, should fail with 404.
"""
self.lg.info('Get vdisk (VD0), should succeed with 200')
response = self.vdisks_apis.get_vdisks_vdiskid(self.vdisk_id)
self.assertEqual(response.status_code, 200)
for key in self.body.keys():
if not self.readOnly and key == "readOnly":
continue
self.assertEqual(self.body[key], response.json()[key])
self.assertEqual(response.json()['status'], 'halted')
self.lg.info('Get nonexisting vdisk, should fail with 404')
response = self.vdisks_apis.get_vdisks_vdiskid('fake_vdisk')
self.assertEqual(response.status_code, 404)
def test002_list_vdisks(self):
""" GAT-062
*GET:/vdisks*
**Test Scenario:**
#. Create vdisk (VD0).
#. List vdisks, should succeed with 200.
"""
self.lg.info('List vdisks, should succeed with 200')
response = self.vdisks_apis.get_vdisks()
self.assertEqual(response.status_code, 200)
vd0_data = {
"id": self.vdisk_id,
"storageCluster": self.storagecluster,
"type": self.type
}
self.assertIn(vd0_data, response.json())
def test003_create_vdisk(self):
""" GAT-063
*POST:/vdisks*
**Test Scenario:**
#. Create vdisk (VD1). should succeed with 201.
#. List vdisks, (VD1) should be listed.
#. Delete vdisk (VD0), should succeed with 204.
#. Create vdisk with invalid body, should fail with 400.
"""
self.lg.info('Create vdisk (VD1). should succeed with 201')
vdisk_id = self.rand_str()
size = random.randint(1, 50)
vdisk_type = random.choice(self.types)
block_size = random.randint(1, self.size) * 1024 * 1024
readOnly = random.choice([False, True])
body = {
"id": vdisk_id,
"size": size,
"blocksize": block_size,
"type": vdisk_type,
"storagecluster": self.storagecluster,
"readOnly": readOnly
}
response = self.vdisks_apis.post_vdisks(body)
self.assertEqual(response.status_code, 201)
self.lg.info('List vdisks, (VD1) should be listed')
response = self.vdisks_apis.get_vdisks()
self.assertEqual(response.status_code, 200)
self.assertIn(vdisk_id, [x['id'] for x in response.json()])
self.lg.info('Delete vdisk (VD0), should succeed with 204')
response = self.vdisks_apis.delete_vdisks_vdiskid(self.vdisk_id)
self.assertEqual(response.status_code, 204)
self.lg.info('Create vdisk with invalid body, should fail with 400')
body = {"id": self.rand_str()}
response = self.vdisks_apis.post_vdisks(body)
self.assertEqual(response.status_code, 400)
def test004_delete_vdisk(self):
""" GAT-064
*Delete:/vdisks/{vdiskid}*
**Test Scenario:**
#. Create vdisk (VD0).
#. Delete vdisk (VD0), should succeed with 204.
#. List vdisks, (VD0) should be gone.
#. Delete nonexisting vdisk, should fail with 404.
"""
self.lg.info('Delete vdisk (VD0), should succeed with 204')
response = self.vdisks_apis.delete_vdisks_vdiskid(self.vdisk_id)
self.assertEqual(response.status_code, 204)
self.lg.info('List vdisks, (VD0) should be gone')
response = self.vdisks_apis.get_vdisks()
self.assertEqual(response.status_code, 200)
self.assertNotIn(self.vdisk_id, [x['id'] for x in response.json()])
self.lg.info('Delete nonexisting vdisk, should fail with 404')
response = self.vdisks_apis.delete_vdisks_vdiskid('fake_vdisk')
self.assertEqual(response.status_code, 404)
def test005_resize_vdisk(self):
""" GAT-065
*POST:/vdisks/{vdiskid}/resize*
**Test Scenario:**
#. Create vdisk (VD0).
#. Resize vdisk (VD0), should succeed with 204.
#. Check that size of volume changed, should succeed.
#. Resize vdisk (VD0) with value less than the current vdisk size, should fail with 400.
#. Check vdisk (VD0) size, shouldn't be changed.
"""
self.lg.info('Resize vdisk (VD0), should succeed with 204')
new_size = self.size + random.randint(1, 10)
body = {"newSize": new_size}
response = self.vdisks_apis.post_vdisks_vdiskid_resize(
self.vdisk_id, body)
self.assertEqual(response.status_code, 204)
self.lg.info('Check that size of volume changed, should succeed')
response = self.vdisks_apis.get_vdisks_vdiskid(self.vdisk_id)
self.assertEqual(response.status_code, 200)
self.assertEqual(new_size, response.json()['size'])
self.size = new_size
self.lg.info(
'Resize vdisk (VD0) with value less than the current vdisk size, should fail with 400'
)
new_size = self.size - random.randint(1, self.size - 1)
body = {"newSize": new_size}
response = self.vdisks_apis.post_vdisks_vdiskid_resize(
self.vdisk_id, body)
self.assertEqual(response.status_code, 400)
self.lg.info('Check vdisk (VD0) size, shouldn\'t be changed')
response = self.vdisks_apis.get_vdisks_vdiskid(self.vdisk_id)
self.assertEqual(response.status_code, 200)
self.assertNotEqual(new_size, response.json()['size'])
@unittest.skip('Not implemented')
def test006_Rollback_vdisk(self):
""" GAT-066
*POST:/vdisks/{vdiskid}/rollback*
**Test Scenario:**
#. Create vdisk (VD0), should succeed.
#. Resize vdisk (VD0), should succeed.
#. Check that size of vdisk (VD0) changed, should succeed.
#. Rollback vdisk (VD0), should succeed.
#. Check that vdisk (VD0) size is changed to the initial size, should succeed.
"""
self.lg.info(' Resize created volume.')
new_size = self.size + random.randint(1, 10)
body = {"newSize": new_size}
response = self.vdisks_apis.post_volumes_volumeid_resize(
self.vdisk_id, body)
self.assertEqual(response.status_code, 204)
self.lg.info('Check that size of volume changed, should succeed')
response = self.vdisks_apis.get_vdisks_vdiskid(self.vdisk_id)
self.assertEqual(response.status_code, 200)
self.assertEqual(new_size, response.json()['size'])
self.lg.info('Rollback vdisk (VD0), should succeed')
body = {"epoch": self.vd_creation_time}
response = self.vdisks_apis.post_vdisks_vdiskid_rollback(
self.vdisk_id, body)
self.assertEqual(response.status_code, 204)
self.lg.info(
'Check that vdisk (VD0) size is changed to the initial size, should succeed'
)
response = self.vdisks_apis.get_vdisks_vdiskid(self.vdisk_id)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.size, response.json()['size'])
def setUp(self):
super(TestVdisks, self).setUp()
node = self.get_random_node()
pyclient_ip = [x['ip'] for x in self.nodes if x['id'] == node][0]
self.pyclient = Client(pyclient_ip)
free_disks = self.pyclient.getFreeDisks()
if free_disks == []:
self.skipTest('no free disks to create storagecluster')
storageclusters = self.storageclusters_api.get_storageclusters()
if storageclusters.json() == []:
self.lg.info('Deploy new storage cluster (SC0)')
sc_label = self.rand_str()
sc_servers = random.randint(1, len(free_disks))
sc_drivetype = 'ssd'
sc_slaveNodes = False
sc_nodes = [self.get_random_node()]
sc_body = {
"label": sc_label,
"servers": sc_servers,
"driveType": sc_drivetype,
"slaveNodes": sc_slaveNodes,
"nodes": sc_nodes
}
self.storageclusters_api.post_storageclusters(sc_body)
for _ in range(60):
response = self.storageclusters_api.get_storageclusters_label(
sc_label)
if response.status_code == 200:
if response.json()['status'] == 'ready':
break
else:
time.sleep(3)
else:
time.sleep(10)
else:
self.lg.error(
'storagecluster status is not ready after 180 sec')
else:
sc_label = storageclusters.json()[0]
self.lg.info('Create vdisk (VD0)')
self.vd_creation_time = time.time()
self.vdisk_id = self.rand_str()
self.size = random.randint(1, 50)
self.types = ['boot', 'db', 'cache', 'tmp']
self.type = random.choice(self.types)
self.block_size = random.randint(1, self.size) * 1024 * 1024
self.storagecluster = sc_label
self.readOnly = random.choice([False, True])
self.body = {
"id": self.vdisk_id,
"size": self.size,
"blocksize": self.block_size,
"type": self.type,
"storagecluster": self.storagecluster,
"readOnly": self.readOnly
}
self.vdisks_apis.post_vdisks(self.body)
class TestStoragepoolsAPI(TestcasesBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.storagepool_api = StoragepoolsAPI()
def setUp(self):
super(TestStoragepoolsAPI, self).setUp()
self.nodeid = self.get_random_node()
self.nodeip = [x['ip'] for x in self.nodes if x['id'] == self.nodeid]
self.pyclient = Client(self.nodeip[0])
self.CLEANUP = []
def tearDown(self):
for storagepool in self.CLEANUP:
self.storagepool_api.delete_storagepools_storagepoolname(
self.nodeid, storagepool)
super(TestStoragepoolsAPI, self).tearDown()
def create_storagepool(self):
freeDisks = self.pyclient.getFreeDisks()
if freeDisks == []:
self.skipTest('no free disks on node {}'.format(self.nodeid))
self.lg.info('Create storagepool (SP0) on node (N0)')
name = self.random_string()
metadata = 'single'
data = 'single'
device = random.choice(freeDisks)
body = {
"name": name,
"metadataProfile": metadata,
"dataProfile": data,
"devices": [device]
}
response = self.storagepool_api.post_storagepools(self.nodeid, body)
self.assertEqual(response.status_code, 201)
for _ in range(60):
freeDisks = self.pyclient.getFreeDisks()
if device not in freeDisks:
self.CLEANUP.append(name)
break
else:
time.sleep(3)
else:
self.lg.error('storagepool {} doesn\'t mount device {}'.format(
name, device))
return body
def delete_storage_pool(self, storagepool):
response = self.storagepool_api.delete_storagepools_storagepoolname(
self.nodeid, storagepool)
if response.status_code == 204:
try:
self.CLEANUP.remove(storagepool)
except:
pass
def create_filesystem(self, storagepool):
self.lg.info(
'Create filesystem (FS0) on storagepool {}'.format(storagepool))
name = self.random_string()
quota = random.randint(0, 10)
body = {"name": name, "quota": quota}
response = self.storagepool_api.post_storagepools_storagepoolname_filesystems(
self.nodeid, storagepool, body)
self.assertEqual(response.status_code, 201)
for _ in range(60):
try:
data = self.pyclient.client.btrfs.subvol_list(
'/mnt/storagepools/{}'.format(storagepool))
filesystems = [x for x in data if 'filesystems' in x['Path']]
filesystems = [
x['Path'][x['Path'].rfind('/') + 1:] for x in filesystems
]
if name in filesystems:
break
else:
time.sleep(3)
except:
pass
else:
self.lg.error('filesystem {} is not created {}'.format(name))
return body
def create_snapshot(self, storagepool, filesystem):
self.lg.info(
'Create snapshot (SS0) of filesystem {}'.format(filesystem))
name = self.rand_str()
body = {"name": name}
self.storagepool_api.post_filesystems_snapshots(
self.nodeid, storagepool, filesystem, body)
for _ in range(60):
try:
data = self.pyclient.client.btrfs.subvol_list(
'/mnt/storagepools/{}'.format(storagepool))
snapshots = [
x for x in data
if 'snapshots/{}'.format(filesystem) in x['Path']
]
snapshots = [
x['Path'][x['Path'].rfind('/') + 1:] for x in snapshots
]
if name in snapshots:
break
else:
time.sleep(3)
except:
pass
else:
self.lg.error('snapshot {} is not created {}'.format(name))
return body
def test001_get_storagepool(self):
""" GAT-045
**Test Scenario:**
#. Create storagepool (SP0) on node (N0), should succeed.
#. Get storagepool (SP0), should succeed with 200.
#. Get storagepool (SP0) using python client, should be listed
#. Get nonexisting storagepool, should fail with 404.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Get storagepool (SP0), should succeed with 200')
response = self.storagepool_api.get_storagepools_storagepoolname(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 200)
for key in storagepool.keys():
if key == 'devices':
continue
self.assertEqual(response.json()[key], storagepool[key])
self.lg.info(
'Get storagepool (SP0) using python client, should be listed')
storagepools = self.pyclient.client.btrfs.list()
storagepool_sp0 = [
x for x in storagepools
if x['label'] == 'sp_{}'.format(storagepool['name'])
]
self.assertNotEqual(storagepool_sp0, [])
for device in storagepool['devices']:
self.assertIn(
device,
[x['path'][:-1] for x in storagepool_sp0[0]['devices']])
self.lg.info('Get nonexisting storagepool, should fail with 404')
response = self.storagepool_api.get_storagepools_storagepoolname(
self.nodeid, 'fake_storagepool')
self.assertEqual(response.status_code, 404)
def test002_list_storagepool(self):
""" GAT-046
**Test Scenario:**
#. Create Storagepool (SP0) on node (N0).
#. list node (N0) storagepools, storagepool (SP0) should be listed.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info(
'list node (N0) storagepools, storagepool (SP0) should be listed')
response = self.storagepool_api.get_storagepools(self.nodeid)
self.assertEqual(response.status_code, 200)
self.assertIn(storagepool['name'],
[x['name'] for x in response.json()])
def test003_post_storagepool(self):
""" GAT-047
**Test Scenario:**
#. Get random nodid (N0).
#. Create storagepool (SP0) on node (N0).
#. Get storagepool (SP0), should succeed with 200.
#. Get storagepool (SP1) using python client, should be listed
#. Delete Storagepool (SP0), should succeed with 204.
#. Create invalid storagepool (missing required params), should fail with 400.
"""
self.lg.info('Create Storagepool (SP1), should succeed with 201')
name = self.random_string()
free_devices = self.pyclient.getFreeDisks()
levels = [
'raid0', 'raid1', 'raid5', 'raid6', 'raid10', 'dup', 'single'
]
if free_devices == []:
self.skipTest('no free disks on node {}'.format(self.nodeid))
if len(free_devices) < 6:
metadata = 'single'
data = 'single'
devices = [random.choice(free_devices)]
else:
metadata = self.random_item(levels)
data = self.random_item(levels)
devices = free_devices[:4]
body = {
"name": name,
"metadataProfile": metadata,
"dataProfile": data,
"devices": devices
}
response = self.storagepool_api.post_storagepools(self.nodeid, body)
self.assertEqual(response.status_code, 201)
time.sleep(30)
self.lg.info('Get Storagepool (SP1), should succeed with 200')
response = self.storagepool_api.get_storagepools_storagepoolname(
self.nodeid, name)
self.assertEqual(response.status_code, 200)
for key in body.keys():
if key == 'devices':
continue
self.assertEqual(response.json()[key], body[key])
time.sleep(20)
self.lg.info(
'Get storagepool (SP0) using python client, should be listed')
storagepools = self.pyclient.client.btrfs.list()
storagepool_sp1 = [
x for x in storagepools if x['label'] == 'sp_{}'.format(name)
]
self.assertNotEqual(storagepool_sp1, [])
for device in devices:
self.assertIn(
device,
[x['path'][:-1] for x in storagepool_sp1[0]['devices']])
self.lg.info('Delete Storagepool (SP0), should succeed with 204')
response = self.storagepool_api.delete_storagepools_storagepoolname(
self.nodeid, name)
self.assertEqual(response.status_code, 204)
self.lg.info('Create invalid storagepool, should fail with 400')
body = {"name": name, "metadataProfile": metadata}
response = self.storagepool_api.post_storagepools(self.nodeid, body)
self.assertEqual(response.status_code, 400)
def test004_delete_storagepool(self):
""" GAT-048
**Test Scenario:**
#. Create Storagepool (SP0) on node (N0).
#. Delete Storagepool (SP0), should succeed with 204.
#. list node (N0) storagepools, storagepool (SP0) should be gone.
#. Delete nonexisting storagepool, should fail with 404.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Delete storagepool (SP0), should succeed with 204')
response = self.storagepool_api.delete_storagepools_storagepoolname(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 204)
self.CLEANUP.remove(storagepool['name'])
self.lg.info(
'list node (N0) storagepools, storagepool (SP0) should be gone')
response = self.storagepool_api.get_storagepools(self.nodeid)
self.assertEqual(response.status_code, 200)
self.assertNotIn(storagepool['name'],
[x['name'] for x in response.json()])
self.lg.info('Delete nonexisting storagepool, should fail with 404')
response = self.storagepool_api.delete_storagepools_storagepoolname(
self.nodeid, 'fake_storagepool')
self.assertEqual(response.status_code, 404)
@unittest.skip('https://github.com/g8os/resourcepool/issues/93')
def test005_get_storagepool_device(self):
""" GAT-049
**Test Scenario:**
#. Create storagepool (SP0) with device (DV0) on node (N0).
#. Get device (DV0), should succeed with 200.
#. Get nonexisting device, should fail with 404.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Get device (DV0), should succeed with 200')
response = self.storagepool_api.get_storagepools_storagepoolname_devices(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 200)
device_uuid = response.json()[0]['uuid']
response = self.storagepool_api.get_storagepools_storagepoolname_devices_deviceid(
self.nodeid, storagepool['name'], device_uuid)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['uuid'], device_uuid)
self.assertEqual(response.json()['status'], 'healthy')
self.lg.info('Get nonexisting device, should fail with 404')
response = self.storagepool_api.get_storagepools_storagepoolname_devices_deviceid(
self.nodeid, storagepool['name'], 'fake_device')
self.assertEqual(response.status_code, 404)
@unittest.skip('https://github.com/g8os/resourcepool/issues/93')
def test006_list_storagepool_devices(self):
""" GAT-050
**Test Scenario:**
#. Create storagepool (SP0) with device (DV0) on node (N0).
#. list storagepool (SP0) devices, should succeed with 200.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('list storagepool (SP0) devices, should succeed with 200')
response = self.storagepool_api.get_storagepools_storagepoolname_devices(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()), 1)
self.assertEqual(response.json()[0]['status'], 'healthy')
@unittest.skip('https://github.com/g8os/resourcepool/issues/93')
def test007_post_storagepool_device(self):
""" GAT-051
**Test Scenario:**
#. Get random nodid (N0).
#. Create storagepool (SP0) with device (DV0) on node (N0).
#. Create device (DV1) on storagepool (SP0), should succeed with 201.
#. list storagepool (SP0) devices, device (DV1) should be listed.
#. Create device with invalid body, should fail with 400.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info(
'Create device (DV1) on storagepool (SP0), should succeed with 201'
)
free_devices = self.pyclient.getFreeDisks()
if free_devices == []:
self.skipTest('no free disks on node {}'.format(self.nodeid))
device = random.choice(free_devices)
body = [device]
response = self.storagepool_api.post_storagepools_storagepoolname_devices(
self.nodeid, storagepool['name'], body)
self.assertEqual(response.status_code, 204)
time.sleep(10)
self.lg.info('list storagepool (SP0) devices, should succeed with 200')
response = self.storagepool_api.get_storagepools_storagepoolname_devices(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 200)
self.assertIn(device, [x['deviceName'][:-1] for x in response.json()])
self.lg.info('Create device with invalid body, should fail with 400')
body = self.random_string()
response = self.storagepool_api.post_storagepools_storagepoolname_devices(
self.nodeid, self.storagepool_name, body)
self.assertEqual(response.status_code, 404)
@unittest.skip('https://github.com/g8os/resourcepool/issues/93')
def test008_delete_storagepool_device(self):
""" GAT-052
**Test Scenario:**
#. Create storagepool (SP0) with device (DV0) on node (N1), should succeed with 201.
#. Delete device (DV0), should succeed with 204.
#. list storagepool (SP0) devices, device (DV0) should be gone.
#. Delete nonexisting device, should fail with 404.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info(
'Create device (DV1) on storagepool (SP0), should succeed with 201'
)
device = random.choice(self.pyclient.getFreeDisks())
body = [device]
response = self.storagepool_api.post_storagepools_storagepoolname_devices(
self.nodeid, storagepool['name'], body)
self.assertEqual(response.status_code, 204)
time.sleep(10)
self.lg.info(
'list storagepool (SP0) devices, device (DV0) should be gone')
response = self.storagepool_api.get_storagepools_storagepoolname_devices(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 200)
deviceuuid = [
x['uuid'] for x in response.json()
if x['deviceName'][:-1] == device
]
self.assertNotEqual(deviceuuid, [],
'device was not added to storagepool')
self.lg.info('Delete device (DV1), should succeed with 204')
response = self.storagepool_api.delete_storagepools_storagepoolname_devices_deviceid(
self.nodeid, storagepool['name'], deviceuuid[0])
self.assertEqual(response.status_code, 204)
time.sleep(10)
self.lg.info(
'list storagepool (SP0) devices, device (DV0) should be gone')
response = self.storagepool_api.get_storagepools_storagepoolname_devices(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 200)
self.assertNotIn(device,
[x['deviceName'][:-1] for x in response.json()])
self.lg.info('Delete nonexisting device, should fail with 404')
response = self.storagepool_api.delete_storagepools_storagepoolname_devices_deviceid(
self.nodeid, self.storagepool_name, 'fake_device')
self.assertEqual(response.status_code, 404)
def test009_get_storagepool_filessystem(self):
""" GAT-053
**Test Scenario:**
#. Create storagepool (SP0) on node (N0), should succeed.
#. Create filesystem (FS0) on storagepool (SP0).
#. Get filesystem (FS0), should succeed with 200.
#. Get nonexisting filesystem, should fail with 404.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Create filesystem (FS0) on storagepool (SP0)')
filesystem = self.create_filesystem(storagepool['name'])
self.lg.info('Get filesystem (FS0), should succeed with 200')
response = self.storagepool_api.get_storagepools_storagepoolname_filesystems_filesystemname(
self.nodeid, storagepool['name'], filesystem['name'])
self.assertEqual(response.status_code, 200)
for key in filesystem.keys():
self.assertEqual(response.json()[key], filesystem[key])
self.lg.info('Get nonexisting filesystem, should fail with 404')
response = self.storagepool_api.get_storagepools_storagepoolname_filesystems_filesystemname(
self.nodeid, storagepool['name'], 'fake_filesystem')
self.assertEqual(response.status_code, 404)
def test010_list_storagepool_filesystems(self):
""" GAT-054
**Test Scenario:**
#. Create Storagepool (SP0) on node (N0).
#. Create filesystem (FS0) on storagepool (SP0).
#. list storagepools (SP0) filesystems, filesystem (FS0) should be listed.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Create filesystem (FS0) on storagepool (SP0)')
filesystem = self.create_filesystem(storagepool['name'])
self.lg.info(
'list storagepools (SP0) filesystems, filesystem (FS0) should be listed'
)
response = self.storagepool_api.get_storagepools_storagepoolname_filesystems(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 200)
self.assertIn(filesystem['name'], response.json())
def test011_post_storagepool_filesystem(self):
""" GAT-055
**Test Scenario:**
#. Get random nodid (N0).
#. Create storagepool (SP0) on node (N0).
#. Create filesystem (FS1) on storagepool (SP0), should succeed with 201.
#. Get filesystem (FS1), should succeed with 200.
#. Delete filesystem (FS1), should succeed with 204.
#. Create invalid filesystem (missing required params), should fail with 400.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info(
'Create filesystem (FS1) on storagepool (SP0), should succeed with 201'
)
name = self.random_string()
quota = random.randint(0, 10)
body = {"name": name, "quota": quota}
response = self.storagepool_api.post_storagepools_storagepoolname_filesystems(
self.nodeid, storagepool['name'], body)
self.assertEqual(response.status_code, 201)
time.sleep(5)
self.lg.info('Get filesystem (FS1), should succeed with 200')
response = self.storagepool_api.get_storagepools_storagepoolname_filesystems_filesystemname(
self.nodeid, storagepool['name'], name)
self.assertEqual(response.status_code, 200)
for key in body.keys():
self.assertEqual(response.json()[key], body[key])
self.lg.info('Delete filesystem (FS1), should succeed with 204')
response = self.storagepool_api.delete_storagepools_storagepoolname_filesystems_filesystemname(
self.nodeid, storagepool['name'], name)
self.assertEqual(response.status_code, 204)
self.lg.info(
'Create filesystem with invalid body, should fail with 400')
body = {self.random_string(): self.random_string()}
response = self.storagepool_api.post_storagepools_storagepoolname_filesystems(
self.nodeid, storagepool['name'], body)
self.assertEqual(response.status_code, 400)
def test012_delete_storagepool_filesystem(self):
""" GAT-056
**Test Scenario:**
#. Create Storagepool (SP0) on node (N0).
#. Create filesystem (FS0) on storagepool (SP0).
#. Delete filesystem (FS0), should succeed with 204.
#. list storagepool (SP0) filesystems, filesystem (FS0) should be gone.
#. Delete nonexisting filesystems, should fail with 404.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Create filesystem (FS0) on storagepool (SP0)')
filesystem = self.create_filesystem(storagepool['name'])
self.lg.info('Delete filesystem (FS0), should succeed with 204')
response = self.storagepool_api.delete_storagepools_storagepoolname_filesystems_filesystemname(
self.nodeid, storagepool['name'], filesystem['name'])
self.assertEqual(response.status_code, 204)
self.lg.info(
'list storagepool (SP0) filesystems, filesystem (FS0) should be gone'
)
response = self.storagepool_api.get_storagepools_storagepoolname_filesystems(
self.nodeid, storagepool['name'])
self.assertEqual(response.status_code, 200)
self.assertNotIn(filesystem['name'], response.json())
self.lg.info('Delete nonexisting filesystems, should fail with 404')
response = self.storagepool_api.delete_storagepools_storagepoolname_filesystems_filesystemname(
self.nodeid, storagepool['name'], 'fake_filesystem')
self.assertEqual(response.status_code, 404)
def test013_get_storagepool_filessystem_snapshot(self):
""" GAT-057
**Test Scenario:**
#. Create storagepool (SP0) on node (N0), should succeed.
#. Create filesystem (FS0) on storagepool (SP0).
#. Create snapshot (SS0) on filesystem (FS0).
#. Get snapshot (SS0), should succeed with 200.
#. Get nonexisting snapshot, should fail with 404.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Create filesystem (FS0) on storagepool (SP0)')
filesystem = self.create_filesystem(storagepool['name'])
self.lg.info('Create snapshot (SS0) on filesystem (FS0)')
snapshot = self.create_snapshot(storagepool['name'],
filesystem['name'])
self.lg.info('Get snapshot (SS0), should succeed with 200')
response = self.storagepool_api.get_filesystem_snapshots_snapshotname(
self.nodeid, storagepool['name'], filesystem['name'],
snapshot['name'])
self.assertEqual(response.status_code, 200)
for key in snapshot.keys():
self.assertEqual(response.json()[key], snapshot[key])
self.lg.info('Get nonexisting snapshot, should fail with 404')
response = self.storagepool_api.get_filesystem_snapshots_snapshotname(
self.nodeid, storagepool['name'], filesystem['name'],
'fake_snapshot')
self.assertEqual(response.status_code, 404)
def test014_list_storagepool_filesystems_snapshots(self):
""" GAT-058
**Test Scenario:**
#. Create storagepool (SP0) on node (N0), should succeed.
#. Create filesystem (FS0) on storagepool (SP0).
#. Create snapshot (SS0) on filesystem (FS0).
#. list snapshots of filesystems (FS0), snapshot (SS0) should be listed.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Create filesystem (FS0) on storagepool (SP0)')
filesystem = self.create_filesystem(storagepool['name'])
self.lg.info('Create snapshot (SS0) on filesystem (FS0)')
snapshot = self.create_snapshot(storagepool['name'],
filesystem['name'])
self.lg.info(
'list snapshots of filesystems (FS0), snapshot (SS0) should be listed'
)
response = self.storagepool_api.get_filesystem_snapshots(
self.nodeid, storagepool['name'], filesystem['name'])
self.assertEqual(response.status_code, 200)
self.assertIn(snapshot['name'], response.json())
def test015_post_storagepool_filesystem_snapshot(self):
""" GAT-059
**Test Scenario:**
#. Create storagepool (SP0) on node (N0), should succeed.
#. Create filesystem (FS0) on storagepool (SP0).
#. Create snapshot (SS1) on filesystem (FS0).
#. Get snapshot (SS1), should succeed with 200.
#. Delete snapshot (SS1), should succeed with 204.
#. Create snapshot with missing required params, should fail with 400.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Create filesystem (FS0) on storagepool (SP0)')
filesystem = self.create_filesystem(storagepool['name'])
self.lg.info('Create snapshot (SS1) on filesystem (FS0)')
name = self.random_string()
body = {"name": name}
response = self.storagepool_api.post_filesystems_snapshots(
self.nodeid, storagepool['name'], filesystem['name'], body)
self.assertEqual(response.status_code, 201)
self.lg.info(' Get snapshot (SS1), should succeed with 200')
response = self.storagepool_api.get_filesystem_snapshots_snapshotname(
self.nodeid, storagepool['name'], filesystem['name'], name)
self.assertEqual(response.status_code, 200)
for key in body.keys():
self.assertEqual(response.json()[key], body[key])
self.lg.info('Delete snapshot (SS1), should succeed with 204')
response = self.storagepool_api.delete_filesystem_snapshots_snapshotname(
self.nodeid, storagepool['name'], filesystem['name'], name)
self.assertEqual(response.status_code, 204)
self.lg.info(
'Create snapshot with missing required params, should fail with 400'
)
body = {}
response = self.storagepool_api.post_filesystems_snapshots(
self.nodeid, storagepool['name'], filesystem['name'], body)
self.assertEqual(response.status_code, 400)
def test016_delete_storagepool_filesystem_snapshot(self):
""" GAT-060
**Test Scenario:**
#. Get random nodid (N0), should succeed.
#. Create storagepool (SP0) on node (N0), should succeed.
#. Create filesystem (FS0) on storagepool (SP0).
#. Create snapshot (SS0) on filesystem (FS0).
#. Delete snapshot (SS0), should succeed with 204.
#. list filesystem (FS0) snapshots, snapshot (SS0) should be gone.
#. Delete nonexisting snapshot, should fail with 404.
"""
self.lg.info('Create storagepool (SP0) on node (N0), should succeed')
storagepool = self.create_storagepool()
self.lg.info('Create filesystem (FS0) on storagepool (SP0)')
filesystem = self.create_filesystem(storagepool['name'])
self.lg.info('Create snapshot (SS0) on filesystem (FS0)')
snapshot = self.create_snapshot(storagepool['name'],
filesystem['name'])
self.lg.info('Delete snapshot (SS0), should succeed with 204')
response = self.storagepool_api.delete_filesystem_snapshots_snapshotname(
self.nodeid, storagepool['name'], filesystem['name'],
snapshot['name'])
self.assertEqual(response.status_code, 204)
self.lg.info(
'list filesystem (FS0) snapshots, snapshot (SS0) should be gone')
response = self.storagepool_api.get_filesystem_snapshots(
self.nodeid, storagepool['name'], filesystem['name'])
self.assertEqual(response.status_code, 200)
self.assertNotIn(snapshot['name'], response.json())
self.lg.info('Delete nonexisting snapshot, should fail with 404')
response = self.storagepool_api.delete_filesystem_snapshots_snapshotname(
self.nodeid, storagepool['name'], filesystem['name'],
'fake_filesystem')
self.assertEqual(response.status_code, 404)
def setUp(self):
super(TestStoragepoolsAPI, self).setUp()
self.nodeid = self.get_random_node()
self.nodeip = [x['ip'] for x in self.nodes if x['id'] == self.nodeid]
self.pyclient = Client(self.nodeip[0])
self.CLEANUP = []
class TestStorageclustersAPI(TestcasesBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.storageclusters_api = Storageclusters()
def setUp(self):
super(TestStorageclustersAPI, self).setUp()
self.nodeid = self.get_random_node()
pyclient_ip = [x['ip'] for x in self.nodes
if x['id'] == self.nodeid][0]
self.pyclient = Client(pyclient_ip)
if self._testMethodName != 'test003_deploy_new_storagecluster':
self.lg.info('Deploy new storage cluster (SC0)')
free_disks = self.pyclient.getFreeDisks()
if free_disks == []:
self.skipTest('no free disks to create storagecluster')
self.label = self.rand_str()
self.servers = randint(1, len(free_disks))
self.drivetype = 'ssd'
self.slaveNodes = False
self.body = {
"label": self.label,
"servers": self.servers,
"driveType": self.drivetype,
"slaveNodes": self.slaveNodes,
"nodes": [self.nodeid]
}
self.storageclusters_api.post_storageclusters(self.body)
for _ in range(60):
response = self.storageclusters_api.get_storageclusters_label(
self.label)
if response.status_code == 200:
if response.json()['status'] == 'ready':
break
else:
time.sleep(3)
else:
time.sleep(10)
else:
self.lg.error(
'storagecluster status is not ready after 180 sec')
def tearDown(self):
self.lg.info('Kill storage cluster (SC0)')
if self._testMethodName != 'test003_deploy_new_storagecluster':
self.storageclusters_api.delete_storageclusters_label(self.label)
super(TestStorageclustersAPI, self).tearDown()
def test001_get_storageclusters_label(self):
""" GAT-041
**Test Scenario:**
#. Deploy new storage cluster (SC0)
#. Get storage cluster (SC0), should succeed with 200
#. Get nonexisting storage cluster (SC0), should fail with 404
"""
self.lg.info('Get storage cluster (SC0), should succeed with 200')
response = self.storageclusters_api.get_storageclusters_label(
self.label)
self.assertEqual(response.status_code, 200)
for key in ['label', 'driveType', 'nodes']:
self.assertEqual(response.json()[key], self.body[key])
self.assertNotEqual(response.json()['status'], 'error')
self.lg.info(
'Get nonexisting storage cluster (SC0), should fail with 404')
response = self.storageclusters_api.get_storageclusters_label(
'fake_label')
self.assertEqual(response.status_code, 404)
def test002_list_storageclusters(self):
""" GAT-042
**Test Scenario:**
#. Deploy new storage cluster (SC0)
#. List storage clusters, should succeed with 200
"""
self.lg.info('Get storage cluster (SC0), should succeed with 200')
response = self.storageclusters_api.get_storageclusters()
self.assertEqual(response.status_code, 200)
self.assertIn(self.label, response.json())
def test003_deploy_new_storagecluster(self):
""" GAT-043
**Test Scenario:**
#. Deploy new storage cluster (SC1), should succeed with 201
#. List storage clusters, (SC1) should be listed
#. Kill storage cluster (SC0), should succeed with 204
"""
self.lg.info(
'Deploy new storage cluster (SC1), should succeed with 201')
free_disks = self.pyclient.getFreeDisks()
if free_disks == []:
self.skipTest('no free disks to create storagecluster')
label = self.rand_str()
servers = randint(1, len(free_disks))
drivetype = 'ssd'
slaveNodes = False
body = {
"label": label,
"servers": servers,
"driveType": drivetype,
"slaveNodes": slaveNodes,
"nodes": [self.nodeid]
}
response = self.storageclusters_api.post_storageclusters(body)
self.assertEqual(response.status_code, 201)
for _ in range(60):
response = self.storageclusters_api.get_storageclusters_label(
label)
if response.status_code == 200:
if response.json()['status'] == 'ready':
break
else:
time.sleep(3)
else:
time.sleep(10)
else:
self.lg.error('storagecluster status is not ready after 180 sec')
self.lg.info('List storage clusters, (SC1) should be listed')
response = self.storageclusters_api.get_storageclusters()
self.assertEqual(response.status_code, 200)
self.assertIn(label, response.json())
self.lg.info('Kill storage cluster (SC1), should succeed with 204')
response = self.storageclusters_api.delete_storageclusters_label(label)
self.assertEqual(response.status_code, 204)
def test004_kill_storagecluster_label(self):
""" GAT-044
**Test Scenario:**
#. #. Deploy new storage cluster (SC0)
#. Kill storage cluster (SC0), should succeed with 204
#. List storage clusters, (SC0) should be gone
#. Kill nonexisting storage cluster, should fail with 404
"""
self.lg.info('Kill storage cluster (SC0), should succeed with 204')
response = self.storageclusters_api.delete_storageclusters_label(
self.label)
self.assertEqual(response.status_code, 204)
self.lg.info('List storage clusters, (SC0) should be gone')
response = self.storageclusters_api.get_storageclusters()
self.assertEqual(response.status_code, 200)
self.assertNotIn(self.label, response.json())
self.lg.info('Kill nonexisting storage cluster, should fail with 404')
response = self.storageclusters_api.delete_storageclusters_label(
'fake_label')
self.assertEqual(response.status_code, 404)
class TestNodeidAPI(TestcasesBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.nodes_api = NodesAPI()
def setUp(self):
self.lg.info('Choose one random node of list of running nodes.')
self.node_id = self.get_random_node()
if self.node_id is None:
self.lg.info(' No node found')
return
self.node = {}
for node in self.nodes:
if node['id'] == self.node_id:
self.g8os_ip = node['ip']
self.node = node
break
self.python_client = Client(self.g8os_ip)
def test001_list_nodes(self):
""" GAT-001
*GET:/node/ Expected: List of all nodes*
**Test Scenario:**
#. Send get nodes api request.
#. Compare results with golden value.
"""
self.lg.info('send get nodes api request ')
response = self.nodes_api.get_nodes()
self.assertEqual(response.status_code, 200)
self.lg.info('Compare results with golden value.')
Running_nodes = []
Nodes_result = response.json()
for node in Nodes_result:
if node['status'] == 'running':
Running_nodes.append(node)
self.assertEqual(len(Running_nodes), len(self.nodes))
for node in Running_nodes:
node_info = [
item for item in self.nodes if item["id"] == node["id"]
]
self.assertEqual(len(node_info), 1)
for key in node.keys():
if key in node_info[0].keys():
self.assertEqual(node[key], node_info[0][key])
def test002_get_nodes_details(self):
""" GAT-002
*GET:/nodes/{nodeid} - Expected: id, status, hostname*
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Send get nodes/{nodeid} api request.
#. Compare results with golden value.
"""
self.lg.info(' Send get nodes/{nodeid} api request.')
response = self.nodes_api.get_nodes_nodeid(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('Compare results with golden value.')
node_details = response.json()
for key in self.node.keys():
if key in node_details.keys():
self.assertEqual(self.node[key], node_details[key])
def test003_list_jobs(self):
""" GAT-003
*GET:/nodes/{nodeid}/jobs - Expected: job list items*
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Send get /nodes/{nodeid}/jobs api request.
#. Compare results with golden value.
"""
self.lg.info('Send get /nodes/{nodeid}/jobs api request.')
response = self.nodes_api.get_nodes_nodeid_jobs(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('Compare results with golden value.')
jobs = response.json()
client_jobs = self.python_client.get_jobs_list()
self.assertEqual(len(jobs), len(client_jobs))
for job in jobs:
for client_job in client_jobs:
if job['id'] == client_job['id']:
self.assertEqual(job['startTime'], client_job['starttime'])
break
def test004_kill_jobs(self):
""" GAT-004
*DELETE:/nodes/{nodeid}/jobs *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Send get /nodes/{nodeid}/jobs api request.
#. Check that all jobs has been killed.
"""
self.lg.info(' Send get /nodes/{nodeid}/jobs api request.')
response = self.nodes_api.delete_nodes_nodeid_jobs(
node_id=self.node_id)
self.assertEqual(response.status_code, 204)
self.lg.info('Check that all jobs has been killed.')
response = self.nodes_api.get_nodes_nodeid_jobs(node_id=self.node_id)
jobs_list = response.json()
self.assertEqual(len(jobs_list), 3)
def test005_get_job_details(self):
""" GAT-005
*GET:/nodes/{nodeid}/jobs/{jobid} *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Get list of jobs of this node .
#. Choose one of these jobs to list its details.
#. Send get /nodes/{nodeid}/jobs/{jobid} api request.
#. Compare response with the golden values.
"""
self.lg.info('Get list of jobs of this node .')
response = self.nodes_api.get_nodes_nodeid_jobs(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('Choose one of these jobs to list its details.')
jobs_list = response.json()
job_id = jobs_list[random.randint(0, (len(jobs_list) - 1))]['id']
self.lg.info('Send get /nodes/{nodeid}/jobs/{jobid} api request.')
response = self.nodes_api.get_nodes_nodeid_jobs_jobid(
node_id=self.node_id, job_id=job_id)
self.assertEqual(response.status_code, 200)
self.lg.info('Compare response with the golden values.')
job_details = response.json()
client_jobs = self.python_client.get_jobs_list()
for client_job in client_jobs:
if client_job['id'] == job_id:
for key in job_details.keys():
if key in client_job.keys():
self.assertEqual(job_details[key], client_job[key])
break
def test006_kill_specific_job(self):
""" GAT-006
*DELETE:/nodes/{nodeid}/jobs/{jobid} *
**Test Scenario:**
#. Start new job .
#. delete /nodes/{nodeid}/jobs/{jobid} api.
#. verify this job has been killed.
"""
self.lg.info('start new job ')
job_id = self.python_client.start_job()
self.assertTrue(job_id)
self.lg.info(' delete /nodes/{nodeid}/jobs/{jobid} api.')
response = self.nodes_api.delete_nodes_nodeid_jobs_jobid(
node_id=self.node_id, job_id=job_id)
self.assertEqual(response.status_code, 204)
self.lg.info("verify this job has been killed.")
jobs = self.python_client.get_jobs_list()
self.assertFalse(any(job['id'] == job_id for job in jobs))
def test007_ping_specific_node(self):
""" GAT-007
*POST:/nodes/{nodeid}/ping *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Post /nodes/{nodeid}/ping api.
#. Check response status code.
"""
self.lg.info('post /nodes/{nodeid}/ping api.')
response = self.nodes_api.post_nodes_nodeid_ping(node_id=self.node_id)
self.lg.info('check response status code.')
self.assertEqual(response.status_code, 200)
def test008_get_node_state(self):
""" GAT-008
*GET:/nodes/{nodeid}/state *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. Get /nodes/{nodeid}/state api.
#. Compare response data with the golden values.
"""
self.lg.info(' get /nodes/{nodeid}/state api.')
response = self.nodes_api.get_nodes_nodeid_state(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('Compare response data with the golden values.')
client_state = self.python_client.get_node_state()
node_state = response.json()
for key in node_state.keys():
if key in client_state.keys():
self.assertAlmostEqual(node_state[key],
client_state[key],
delta=2000000,
msg='different value for key%s' % key)
@unittest.skip("https://github.com/g8os/grid/issues/107")
def test009_reboot_node(self):
""" GAT-009
*POST:/nodes/{nodeid}/reboot *
**Test Scenario:**
#. Choose one random node of list of running nodes.
#. post /nodes/{nodeid}/reboot api.
#. verify that this node has been rebooted.
#. Ping node should succeed
"""
self.lg.info('post /nodes/{nodeid}/reboot api.')
response = self.nodes_api.post_nodes_nodeid_reboot(
node_id=self.node_id)
self.assertEqual(response.status_code, 204)
self.lg.info('verify that this node has been rebooted.')
content = response.json()
self.assertEqual(content, 'Machine reboot signal sent successfully')
def test010_get_cpus_details(self):
""" GAT-010
*GET:/nodes/{nodeid}/cpus *
**Test Scenario:**
#. Choose one random node from list of running nodes.
#. get /nodes/{nodeid}/cpus api.
#. compare response data with the golden values.
"""
self.lg.info('get /nodes/{nodeid}/cpus api.')
response = self.nodes_api.get_nodes_nodeid_cpus(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('compare response data with the golden values.')
result = self.python_client.get_nodes_cpus()
cpus_info = response.json()
for i, cpu_info in enumerate(cpus_info):
for key in cpu_info.keys():
if key in result[i].keys():
if key != 'cores' and key != 'mhz':
self.assertEqual(cpu_info[key], result[i][key],
"different cpu info for key %s" % key)
@unittest.skip('https://github.com/g8os/resourcepool/issues/219')
def test011_get_disks_details(self):
""" GAT-011
*GET:/nodes/{nodeid}/disks *
**Test Scenario:**
#. Choose one random node from list of running nodes.
#. Get /nodes/{nodeid}/disks api.
#. Compare response data with the golden values.
"""
self.lg.info('get /nodes/{nodeid}/disks api.')
response = self.nodes_api.get_nodes_nodeid_disks(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
disks_info = response.json()
self.lg.info('compare response data with the golden values.')
result = self.python_client.get_nodes_disks()
for disk_info in disks_info:
for disk in result:
if disk['device'] == disk_info['device']:
for key in disk.keys():
self.assertEqual(disk_info[key], disk[key],
"different value for key%s" % key)
break
def test012_get_memmory_details(self):
""" GAT-012
*GET:/nodes/{nodeid}/mem *
**Test Scenario:**
#. Choose one random node from list of running nodes.
#. get /nodes/{nodeid}/mem api.
#. compare response data with the golden values.
"""
self.lg.info('get /nodes/{nodeid}/mem api.')
response = self.nodes_api.get_nodes_nodeid_mem(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('compare response data with the golden values.')
result = self.python_client.get_nodes_mem()
memory_info = response.json()
for key in memory_info.keys():
if key in result.keys():
self.assertAlmostEqual(memory_info[key],
result[key],
msg="different keys%s" % key,
delta=5000000)
def test013_get_nics_details(self):
""" GAT-013
*GET:/nodes/{nodeid}/nics - network interface information*
**Test Scenario:**
#. Choose one random node from list of running nodes.
#. Get /nodes/{nodeid}/nics api.
#. compare response data with the golden values.
"""
self.lg.info('get /nodes/{nodeid}/nics api.')
response = self.nodes_api.get_nodes_nodeid_nics(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('compare response data with the golden values.')
golden_result = self.python_client.get_nodes_nics()
nics_info = response.json()
self.assertEqual(len(nics_info), len(golden_result))
for nic_info in nics_info:
for nic_result in golden_result:
if nic_result['name'] == nic_info['name']:
for key in nic_info.keys():
if key in nic_result.keys():
self.assertEqual(
nic_info[key], nic_result[key],
'different value for key %s' % key)
break
def test014_get_os_info_details(self):
""" GAT-014
*GET:/nodes/{nodeid}/info - os information*
**Test Scenario:**
#. Choose one random node from list of running nodes.
#. Get /nodes/{nodeid}/info api.
#. ompare response data with the golden values.
"""
self.lg.info('Get /nodes/{nodeid}/info api.')
response = self.nodes_api.get_nodes_nodeid_info(node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('compare response data with the golden values.')
result = self.python_client.get_nodes_info()
node_info = response.json()
for key in node_info.keys():
if key in result.keys():
self.assertEqual(node_info[key], result[key])
def test015_list_processes(self):
""" GAT-015
*GET:/nodes/{nodeid}/process *
**Test Scenario:**
#. Choose one random node from list of running nodes.
#. get /nodes/{nodeid}/processes api.
#. compare response data with the golden values.
"""
self.lg.info('Get /nodes/{nodeid}/process api.')
response = self.nodes_api.get_nodes_nodeid_processes(
node_id=self.node_id)
self.assertEqual(response.status_code, 200)
self.lg.info('compare response data with the golden values.')
processes = {}
client_processes = {}
client_result = self.python_client.get_processes_list()
for process in client_result:
client_processes[process['pid']] = process
for process in response.json():
processes[process['pid']] = process
for process_id in processes.keys():
process_info = processes[process_id]
for info in process_info.keys():
if info != 'cpu':
if info in client_processes[process_id].keys():
if info == 'rss':
self.assertAlmostEqual(
process_info[info],
client_processes[process_id][info],
msg="different value with key%s" % info,
delta=7000000)
elif info == 'vms':
self.assertAlmostEqual(
process_info[info],
client_processes[process_id][info],
msg="different value with key%s" % info,
delta=5000000)
else:
self.assertEqual(
process_info[info],
client_processes[process_id][info],
"different value with key%s" % info)
def test016_get_process_details(self):
""" GAT-016
*GET:/nodes/{nodeid}/processes/{processid} *
**Test Scenario:**
#. Choose one random node from list of running nodes.
#. Get list of running processes
#. choose one of them.
#. Get /nodes/{nodeid}/processes/{processid} api.
#. compare response data with the golden values.
"""
self.lg.info('Get list of running processes')
response = self.nodes_api.get_nodes_nodeid_processes(
node_id=self.node_id)
self.assertEqual(response.status_code, 200)
processes_list = response.json()
self.lg.info('Choose one of these processes to list its details.')
process_id = processes_list[random.randint(0,
len(processes_list) -
1)]['pid']
self.lg.info('Get /nodes/{nodeid}/process/{processid} api.')
response = self.nodes_api.get_nodes_nodeid_processes_processid(
node_id=self.node_id, process_id=str(process_id))
self.assertEqual(response.status_code, 200)
self.lg.info('Compare response data with the golden values.')
process_info = response.json()
client_result = self.python_client.get_processes_list()
for process in client_result:
if process['pid'] == process_info['pid']:
for info in process_info.keys():
if info != 'cpu':
if info in process.keys():
self.assertEqual(
process_info[info], process[info],
"different value with key%s" % info)
break
def test017_delete_process(self):
""" GAT-017
*DELETE:/nodes/{nodeid}/processes/{processid} *
**Test Scenario:**
#. Start new process.
#. Delete /nodes/{nodeid}/processes/{processid} api.
#. Make sure that this process has been killed.
"""
self.lg.info('Start new process.')
process_id = self.python_client.start_process()
self.assertTrue(process_id)
self.lg.info('delete /nodes/{nodeid}/processes/{processid} api.')
response = self.nodes_api.delete_nodes_nodeid_process_processid(
node_id=self.node_id, process_id=str(process_id))
self.assertEqual(response.status_code, 204)
self.lg.info('Make sure that this process has been killed.')
client_processes = self.python_client.get_processes_list()
self.assertFalse(
any(process['pid'] == process_id for process in client_processes))
class TestVmsAPI(TestcasesBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.vms_api = VmsAPI()
self.storageclusters_api = Storageclusters()
self.vdisks_apis = VDisksAPIs()
def setUp(self):
super(TestVmsAPI, self).setUp()
self.lg.info('Get random nodid (N0)')
self.nodeid = self.get_random_node()
nodeip = [x['ip'] for x in self.nodes if x['id'] == self.nodeid][0]
self.pyclient = Client(nodeip)
storageclusters = self.storageclusters_api.get_storageclusters()
if storageclusters.json() == []:
self.storagecluster = self.create_sotragecluster()['label']
else:
self.storagecluster = storageclusters.json()[0]
vdisks = self.vdisks_apis.get_vdisks()
vdisks = [
x for x in vdisks.json()
if (x['id'] == 'ubuntu-test-vdisk'
and x['storageCluster'] == self.storagecluster)
]
if vdisks == []:
self.vdisk = self.create_boot_vdisk(self.storagecluster)
else:
self.vdisk = vdisks[0]
def tearDown(self):
self.lg.info('Delete virtual machine (VM0)')
response = self.vms_api.get_nodes_vms(self.nodeid)
if response.status_code == 200:
vms = response.json()
for vm in vms:
self.vms_api.delete_nodes_vms_vmid(self.nodeid, vm['id'])
super(TestVmsAPI, self).tearDown()
def create_sotragecluster(self):
free_disks = self.pyclient.getFreeDisks()
if free_disks == []:
self.skipTest('no free disks to create storagecluster')
self.lg.info('Deploy new storage cluster (SC0)')
label = self.rand_str()
servers = random.randint(1, len(free_disks))
drivetype = 'ssd'
slaveNodes = False
nodes = [self.nodeid]
body = {
"label": label,
"servers": servers,
"driveType": drivetype,
"slaveNodes": slaveNodes,
"nodes": nodes
}
self.storageclusters_api.post_storageclusters(body)
for _ in range(60):
response = self.storageclusters_api.get_storageclusters_label(
label)
if response.status_code == 200:
if response.json()['status'] == 'ready':
break
else:
time.sleep(3)
else:
time.sleep(10)
else:
self.lg.error('storagecluster status is not ready after 180 sec')
return body
def create_boot_vdisk(self, storagecluster):
body = {
"id": 'ubuntu-test-vdisk',
"size": 15,
"blocksize": 4096,
"type": 'boot',
"storagecluster": storagecluster,
"templatevdisk": "ardb://hub.gig.tech:16379/template:ubuntu-1604"
}
self.vdisks_apis.post_vdisks(body)
time.sleep(30)
return body
def create_vm(self):
self.lg.info('Create virtual machine (VM0) on node (N0)')
vmid = self.random_string()
mem = 1024
cpu = 1
nics = []
disks = [{"vdiskid": "ubuntu-test-vdisk", "maxIOps": 2000}]
userCloudInit = {}
systemCloudInit = {}
body = {
"id": vmid,
"memory": mem,
"cpu": cpu,
"nics": nics,
"disks": disks,
"userCloudInit": userCloudInit,
"systemCloudInit": systemCloudInit
}
self.vms_api.post_nodes_vms(self.nodeid, body)
for _ in range(60):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vmid)
if response.status_code == 200:
if response.json()['status'] == 'running':
break
else:
time.sleep(3)
else:
time.sleep(10)
else:
self.lg.error('vm status is not running after 180 sec')
return body
def test001_get_nodes_vms_vmid(self):
""" GAT-067
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Get virtual machine (VM0), should succeed with 200.
#. Get nonexisting virtual machine, should fail with 404.
"""
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm = self.create_vm()
self.lg.info('Get virtual machine (VM0), should succeed with 200')
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
keys_to_check = ['id', 'memory', 'cpu', 'nics', 'disks']
for key in keys_to_check:
self.assertEqual(vm[key], response.json()[key])
self.assertEqual(response.json()['status'], 'running')
vms_list = self.pyclient.client.kvm.list()
self.assertIn(vm['id'], [x['name'] for x in vms_list])
self.lg.info('Get nonexisting virtual machine, should fail with 404')
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, 'fake_vm')
self.assertEqual(response.status_code, 404)
def test002_get_node_vms(self):
""" GAT-068
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. List node (N0) virtual machines, virtual machine (VM0) should be listed, should succeed with 200.
"""
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm = self.create_vm()
self.lg.info(
'List node (N0) virtual machines, virtual machine (VM0) should be listed, should succeed with 200'
)
response = self.vms_api.get_nodes_vms(self.nodeid)
self.assertEqual(response.status_code, 200)
self.assertIn(vm['id'], [x['id'] for x in response.json()])
def test003_post_node_vms(self):
""" GAT-069
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM1) on node (N0).
#. Get virtual machine (VM1), should succeed with 200.
#. List kvms in python client, (VM1) should be listed.
#. Delete virtual machine (VM1), should succeed with 204.
#. Create virtual machine with missing parameters, should fail with 400.
"""
self.lg.info('Create virtual machine (VM1) on node (N0)')
vm_id = self.random_string()
vm_mem = random.randint(1, 16) * 1024
vm_cpu = random.randint(1, 16)
vm_nics = []
vm_disks = [{"vdiskid": "ubuntu-test-vdisk", "maxIOps": 2000}]
vm_userCloudInit = {}
vm_systemCloudInit = {}
body = {
"id": vm_id,
"memory": vm_mem,
"cpu": vm_cpu,
"nics": vm_nics,
"disks": vm_disks,
"userCloudInit": vm_userCloudInit,
"systemCloudInit": vm_systemCloudInit
}
response = self.vms_api.post_nodes_vms(self.nodeid, body)
self.assertEqual(response.status_code, 201)
time.sleep(20)
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm_id)
self.assertEqual(response.status_code, 200)
if response.json()['status'] == 'error':
vm_id = self.rand_str()
body['id'] = vm_id
body['memory'] = 1024
body['cpu'] = 1
response = self.vms_api.post_nodes_vms(self.nodeid, body)
self.assertEqual(response.status_code, 201)
self.lg.info('Get virtual machine (VM1), should succeed with 200')
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm_id)
self.assertEqual(response.status_code, 200)
keys_to_check = ['id', 'memory', 'cpu', 'nics', 'disks']
for key in keys_to_check:
self.assertEqual(body[key], response.json()[key])
self.assertEqual(response.json()['status'], 'deploying')
for _ in range(60):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm_id)
if response.status_code == 200:
if response.json()['status'] == 'running':
break
else:
time.sleep(3)
else:
time.sleep(10)
else:
raise AssertionError('{} != {}'.format(response.json()['status'],
'running'))
self.lg.info('List kvms in python client, (VM1) should be listed')
vms = self.pyclient.client.kvm.list()
self.assertIn(vm_id, [x['name'] for x in vms])
self.lg.info('Delete virtual machine (VM1), should succeed with 204')
response = self.vms_api.delete_nodes_vms_vmid(self.nodeid, vm_id)
self.assertEqual(response.status_code, 204)
self.lg.info(
'Create virtual machine with missing parameters, should fail with 400'
)
body = {"id": self.random_string()}
response = self.vms_api.post_nodes_vms(self.nodeid, body)
self.assertEqual(response.status_code, 400)
# @unittest.skip('https://github.com/g8os/resourcepool/issues/126')
def test004_put_nodes_vms_vmid(self):
""" GAT-070
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Update virtual machine (VM1), should succeed with 201.
#. Get virtual machine (VM1), should succeed with 200.
#. Update virtual machine with missing parameters, should fail with 400.
"""
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm = self.create_vm()
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm_mem = 2 * 1024
vm_cpu = 2
vm_nics = []
vm_disks = [{"vdiskid": "ubuntu-test-vdisk", "maxIOps": 2000}]
body = {
"memory": vm_mem,
"cpu": vm_cpu,
"nics": vm_nics,
"disks": vm_disks
}
self.lg.info('Stop virtual machine (VM0), should succeed with 204')
response = self.vms_api.post_nodes_vms_vmid_stop(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 204)
self.lg.info(
'Get virtual machine (VM0), virtual machine (VM0) status should be halting'
)
for _ in range(20):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'halted':
break
else:
time.sleep(3)
else:
self.lg.error('can\'t stop vm')
response = self.vms_api.put_nodes_vms_vmid(self.nodeid, vm['id'], body)
self.assertEqual(response.status_code, 204)
self.lg.info('Start virtual machine (VM0), should succeed with 204')
response = self.vms_api.post_nodes_vms_vmid_start(
self.nodeid, vm['id'])
self.assertEqual(response.status_code, 204)
for _ in range(20):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'running':
break
else:
time.sleep(3)
else:
self.lg.error('can\'t start vm')
self.lg.info('Get virtual machine (VM0), should succeed with 200')
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
keys_to_check = ['memory', 'cpu', 'nics', 'disks']
for key in keys_to_check:
self.assertEqual(body[key], response.json()[key])
self.assertEqual(response.json()['status'], 'running')
self.lg.info(
'Update virtual machine with missing parameters, should fail with 400'
)
body = {"id": self.random_string()}
response = self.vms_api.put_nodes_vms_vmid(self.nodeid, vm['id'], body)
self.assertEqual(response.status_code, 400)
def test005_get_nodes_vms_vmid_info(self):
""" GAT-071
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Get virtual machine (VM0) info, should succeed with 200.
#. Get nonexisting virtual machine info, should fail with 404.
"""
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm = self.create_vm()
self.lg.info('Get virtual machine (VM0) info, should succeed with 200')
response = self.vms_api.get_nodes_vms_vmid_info(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
self.lg.info(
'Get nonexisting virtual machine info, should fail with 404')
response = self.vms_api.get_nodes_vms_vmid_info(self.nodeid, 'fake_vm')
def test006_delete_nodes_vms_vmid(self):
""" GAT-072
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Delete virtual machine (VM0), should succeed with 204.
#. List kvms in python client, (VM0) should be gone.
#. Delete nonexisting virtual machine, should fail with 404.
"""
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm = self.create_vm()
self.lg.info('Delete virtual machine (VM0), should succeed with 204')
response = self.vms_api.delete_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 204)
self.lg.info('List kvms in python client, (VM0) should be gone')
vms = self.pyclient.client.kvm.list()
self.assertNotIn(vm['id'], [x['name'] for x in vms])
self.lg.info(
'Delete nonexisting virtual machine, should fail with 404')
response = self.vms_api.delete_nodes_vms_vmid(self.nodeid,
'fake_vm_id')
self.assertEqual(response.status_code, 404)
def test007_post_nodes_vms_vmid_start(self):
""" GAT-073
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Stop virtual machine (VM0), should succeed with 204.
#. Start virtual machine (VM0), should succeed with 204.
#. Get virtual machine (VM0), virtual machine (VM0) status should be running.
"""
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm = self.create_vm()
self.lg.info('Stop virtual machine (VM0), should succeed with 204')
response = self.vms_api.post_nodes_vms_vmid_stop(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 204)
for _ in range(20):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'halted':
break
else:
time.sleep(3)
else:
raise AssertionError('{} is not {}'.format(status, 'halted'))
vms = self.pyclient.client.kvm.list()
vm0 = [x for x in vms if x['name'] == vm['id']]
self.assertEqual(vm0, [])
self.lg.info('Start virtual machine (VM0), should succeed with 204')
response = self.vms_api.post_nodes_vms_vmid_start(
self.nodeid, vm['id'])
self.assertEqual(response.status_code, 204)
for _ in range(20):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'running':
break
else:
time.sleep(3)
else:
raise AssertionError('{} is not {}'.format(status, 'running'))
vms = self.pyclient.client.kvm.list()
vm0 = [x for x in vms if x['name'] == vm['id']]
self.assertNotEqual(vm0, [])
self.assertEquals(vm0[0]['state'], 'running')
def test008_post_nodes_vms_vmid_stop(self):
""" GAT-074
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Stop virtual machine (VM0), should succeed with 204.
#. Get virtual machine (VM0), virtual machine (VM0) status should be halting.
"""
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm = self.create_vm()
self.lg.info('Stop virtual machine (VM0), should succeed with 204')
response = self.vms_api.post_nodes_vms_vmid_stop(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 204)
self.lg.info(
'Get virtual machine (VM0), virtual machine (VM0) status should be halting'
)
for _ in range(20):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'halted':
break
else:
time.sleep(3)
else:
raise AssertionError('{} != {}'.format(status, 'halted'))
vms = self.pyclient.client.kvm.list()
vm0 = [x for x in vms if x['name'] == vm['id']]
self.assertEqual(vm0, [])
def test009_post_nodes_vms_vmid_pause_resume(self):
""" GAT-075
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Pause virtual machine (VM0), should succeed with 204.
#. Get virtual machine (VM0), virtual machine (VM0) status should be paused.
#. Resume virtual machine (VM0), should succeed with 204.
#. Get virtual machine (VM0), virtual machine (VM0) status should be running
"""
self.lg.info('Create virtual machine (VM0) on node (N0)')
vm = self.create_vm()
self.lg.info('Pause virtual machine (VM0), should succeed with 204')
response = self.vms_api.post_nodes_vms_vmid_pause(
self.nodeid, vm['id'])
self.assertEqual(response.status_code, 204)
self.lg.info(
'Get virtual machine (VM0), virtual machine (VM0) status should be halting'
)
for _ in range(15):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'paused':
break
else:
time.sleep(1)
else:
raise AssertionError('{} != {}'.format(status, 'paused'))
vms = self.pyclient.client.kvm.list()
vm0 = [x for x in vms if x['name'] == vm['id']]
self.assertNotEqual(vm0, [])
self.assertEquals(vm0[0]['state'], 'paused')
self.lg.info('Resume virtual machine (VM0), should succeed with 204')
response = self.vms_api.post_nodes_vms_vmid_resume(
self.nodeid, vm['id'])
self.assertEqual(response.status_code, 204)
self.lg.info(
'Get virtual machine (VM0), virtual machine (VM0) status should be running'
)
for _ in range(15):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, vm['id'])
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'running':
break
else:
time.sleep(1)
else:
raise AssertionError('{} != {}'.format(status, 'paused'))
vms = self.pyclient.client.kvm.list()
vm0 = [x for x in vms if x['name'] == vm['id']]
self.assertNotEqual(vm0, [])
self.assertEquals(vm0[0]['state'], 'running')
@unittest.skip('https://github.com/g8os/resourcepool/issues/128')
def test010_post_nodes_vms_vmid_shutdown(self):
""" GAT-076
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Shutdown virtual machine (VM0), should succeed with 204.
#. Get virtual machine (VM0), virtual machine (VM0) status should be halted.
"""
self.lg.info('Shutdown virtual machine (VM0), should succeed with 204')
response = self.vms_api.post_nodes_vms_vmid_shutdown(
self.nodeid, self.vm_id)
self.assertEqual(response.status_code, 204)
for _ in range(15):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, self.vm_id)
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status in ['halting', 'halted']:
break
else:
time.sleep(1)
else:
raise AssertionError('{} not {}'.format(status,
'halting or halted'))
vms = self.pyclient.client.kvm.list()
vm0 = [x for x in vms if x['name'] == self.vm_id]
self.assertEqual(vm0, [])
@unittest.skip('https://github.com/g8os/resourcepool/issues/215')
def test011_post_nodes_vms_vmid_migrate(self):
""" GAT-077
**Test Scenario:**
#. Get random nodid (N0).
#. Create virtual machine (VM0) on node (N0).
#. Migrate virtual machine (VM0) to another node, should succeed with 204.
#. Get virtual machine (VM0), virtual machine (VM0) status should be migrating.
"""
if len(self.nodes) < 2:
self.skipTest('need at least 2 nodes')
self.lg.info(
'Migrate virtual machine (VM0) to another node, should succeed with 204'
)
node_2 = self.get_random_node(except_node=self.nodeid)
body = {"nodeid": node_2}
response = self.vms_api.post_nodes_vms_vmid_migrate(
self.nodeid, self.vm_id, body)
self.assertEqual(response.status_code, 204)
for _ in range(15):
response = self.vms_api.get_nodes_vms_vmid(self.nodeid, self.vm_id)
self.assertEqual(response.status_code, 200)
status = response.json()['status']
if status == 'running':
break
else:
time.sleep(1)
response = self.vms_api.get_nodes_vms_vmid(node_2, self.vm_id)
self.assertEqual(response.status_code, 200)
pyclient_ip = [x['ip'] for x in self.nodes if x['id'] == node_2]
self.assertNotEqual(pyclient_ip, [])
pyclient = Client(pyclient_ip)
vms = pyclient.client.kvm.list()
self.assertIn(self.vm_id, [x['name'] for x in vms])
