def test_REST_connection(self): self.driver = StingrayDriver(conf, device) response = self.driver.send_request('', 'GET')
class StingrayDriverTestCase(unittest.TestCase): driver = StingrayDriver(conf, device) def check_in_list(self, target, field_name, item_to_find): ''' Queries the target URL and field to check if the item is in that Stingray formatted list ''' response = self.driver.send_request(target, 'GET') response_dict = self.driver.response_to_dict(response) if item_to_find in response_dict['properties'][field_name]: found = True else: found = False return found def rest_assert_in_list(self, target, field_name, item_to_find): in_list = self.check_in_list(target, field_name, item_to_find) self.assertTrue(in_list) def rest_assert_not_in_list(self, target, field_name, item_to_find): in_list = self.check_in_list(target, field_name, item_to_find) self.assertFalse(in_list) def check_field_is(self, target, field_name, field_value): '''Checks the value fo a field via a HTTP GET request ''' response = self.driver.send_request(target, 'GET') response_dict = self.driver.response_to_dict(response) found = False if field_value == response_dict['properties'][field_name]: found = True return found def rest_assert_field_is(self, target, field_name, field_value): value_correct = self.check_field_is(target, field_name, field_value) self.assertTrue(value_correct) def check_exists(self, target): '''Checks for a 404 error message after a HTTP GET to signify the resource no longer exists ''' try: self.driver.send_request(target, 'GET') exists = True except HTTPError as e: if e.response.status_code == 404: exists = False else: raise return exists def rest_assert_exists(self, target): exists = self.check_exists(target) self.assertTrue(exists) def rest_assert_does_not_exist(self, target): exists = self.check_exists(target) self.assertFalse(exists) def setUp(self): self.driver.create_server_farm(serverfarm, predictor) return def tearDown(self): self.driver.delete_server_farm(serverfarm) return def test_REST_connection(self): self.driver = StingrayDriver(conf, device) response = self.driver.send_request('', 'GET') def test_real_server_add_remove(self): self.driver.add_real_server_to_server_farm(serverfarm, rserver) self.driver.add_real_server_to_server_farm(serverfarm, rserver_weighted) target = 'pools/' + serverfarm['id'] + '/' node = rserver['address'] + ':' + rserver['port'] node_weighted = (rserver_weighted['address'] + ':' + rserver_weighted['port']) #Check rserveris have both been added to node list self.rest_assert_in_list(target, 'nodes', node) self.rest_assert_in_list(target, 'nodes', node_weighted) self.driver.delete_real_server_from_server_farm(serverfarm, rserver_weighted) #Check that first has been successfully deleted self.rest_assert_not_in_list(target, 'nodes', node_weighted) self.driver.delete_real_server_from_server_farm(serverfarm, rserver) #Check that second has been successfully deleted self.rest_assert_not_in_list(target, 'nodes', node) def test_real_server_weights(self): self.driver.add_real_server_to_server_farm(serverfarm, rserver) self.driver.add_real_server_to_server_farm(serverfarm, rserver_weighted) weighted_node = (rserver_weighted['address'] + ':' + rserver_weighted['port'] + ':' + rserver_weighted['weight']) non_weighted_node = (rserver['address'] + ':' + rserver['port'] + ':1') target = 'pools/' + serverfarm['id'] + '/' #Check that weight field has been updated with correct values self.rest_assert_in_list(target, 'priority!values', weighted_node) self.rest_assert_in_list(target, 'priority!values', non_weighted_node) self.driver.delete_real_server_from_server_farm(serverfarm, rserver) self.driver.delete_real_server_from_server_farm(serverfarm, rserver_weighted) #Check values do not linger after removed from node list self.rest_assert_not_in_list(target, 'priority!values', weighted_node) self.rest_assert_not_in_list(target, 'priority!values', non_weighted_node) def test_create_delete_virtual_ips(self): self.driver.create_virtual_ip(vip, serverfarm) self.driver.create_virtual_ip(vip_2, serverfarm) #Check traffic ip group created vip_target = 'flipper/' + serverfarm['id'] + '/' self.rest_assert_in_list(vip_target, 'ipaddresses', vip['address']) self.rest_assert_in_list(vip_target, 'ipaddresses', vip_2['address']) #Check linked to virtual server vserver_target = 'vservers/' + serverfarm['id'] + '/' response = self.driver.send_request(vserver_target, 'GET') response_dict = self.driver.response_to_dict(response) self.assertEqual('!' + vip['sf_id'], response_dict['properties']['address']) self.driver.delete_virtual_ip(vip) #Check ip deleted but traffic group still linked self.rest_assert_not_in_list(vip_target, 'ipaddresses', vip['address']) self.rest_assert_field_is(vserver_target, 'address', '!' + serverfarm['id']) self.driver.delete_virtual_ip(vip_2) #Check traffic group deleted and no longer linked self.rest_assert_does_not_exist(vip_target) self.rest_assert_field_is(vserver_target, 'address', '') def test_probe_incompatible(self): #Test request for unknown probe type ends in failure self.driver.create_probe(probe_incompatible) target = 'monitors/' + probe_incompatible['id'] + '/' self.rest_assert_does_not_exist(target) def test_probe_add_delete(self): self.driver.create_probe(probe_connect) self.driver.create_probe(probe_http) self.driver.add_probe_to_server_farm(serverfarm, probe_connect) self.driver.add_probe_to_server_farm(serverfarm, probe_http) #Check probe created and added to pool probe_target_connect = 'monitors/' + probe_connect['id'] + '/' probe_target_http = 'monitors/' + probe_http['id'] + '/' self.rest_assert_exists(probe_target_connect) self.rest_assert_exists(probe_target_http) pool_target = 'pools/' + serverfarm['id'] + '/' self.rest_assert_in_list(pool_target, 'monitors', probe_connect['id']) self.rest_assert_in_list(pool_target, 'monitors', probe_http['id']) self.driver.delete_probe_from_server_farm(serverfarm, probe_connect) #Check connect no longer attached to pool but http is self.rest_assert_not_in_list(pool_target, 'monitors', probe_connect['id']) self.rest_assert_in_list(pool_target, 'monitors', probe_http['id']) #Check connect no longer exists self.driver.delete_probe(probe_connect) self.rest_assert_does_not_exist(probe_target_connect) self.driver.delete_probe_from_server_farm(serverfarm, probe_http) self.driver.delete_probe(probe_http) #Check http no longer exists or linked self.rest_assert_not_in_list(pool_target, 'monitors', probe_http['id']) self.rest_assert_does_not_exist(probe_target_http) def test_probe_type_http(self): self.driver.create_probe(probe_http) #Check correct settings for http probe target = 'monitors/' + probe_http['id'] + '/' self.rest_assert_field_is(target, 'type', 'http') self.driver.delete_probe(probe_http) def test_probe_type_https(self): self.driver.create_probe(probe_https) self.driver.add_probe_to_server_farm(serverfarm, probe_https) #Check correct settings for https probe target = 'monitors/' + probe_https['id'] + '/' self.rest_assert_field_is(target, 'type', 'http') self.rest_assert_field_is(target, 'use_ssl', 'Yes') self.driver.delete_probe_from_server_farm(serverfarm, probe_https) self.driver.delete_probe(probe_https) def test_stickiness_add_delete(self): self.driver.create_stickiness(sticky_cookie) #Check session persistence class created and linked to virtual server sticky_target = 'persistence/' + sticky_cookie['id'] + '/' self.rest_assert_exists(sticky_target) vserver_target = 'pools/' + serverfarm['id'] + '/' self.rest_assert_field_is(vserver_target, 'persistence', sticky_cookie['id']) self.driver.delete_stickiness(sticky_cookie) def test_stickiness_type_cookie(self): self.driver.create_stickiness(sticky_cookie) #Check correct settings for http cookie persistence target = 'persistence/' + sticky_cookie['id'] + '/' self.rest_assert_field_is(target, 'type', 'sardine') self.driver.delete_stickiness(sticky_cookie)