def test_invalid_put_method(self):
status_code, response_data = execute_request(
self.url_system,
"PUT",
json.dumps(DATA),
self.SWITCH_IP,
False,
xtra_header=self.cookie_header)
assert status_code == httplib.BAD_REQUEST, ("Wrong status code %s " %
status_code)
info('### PASSED in Execute rest command "PUT" as expected for: ' +
'url: ' + self.url_system + ' ###\n')
info('### Success in INVALID Rest PUT for system ###\n')
status_code, response_data = execute_request(
self.url_system,
"PUT",
json.dumps(PUT_DATA),
self.SWITCH_IP,
False,
xtra_header=self.cookie_header)
assert status_code == httplib.BAD_REQUEST, ("Wrong status code %s " %
status_code)
info('### PASSED in Execute rest command "PUT" as expected for: ' +
'url: ' + self.url_interfaces + ' ###\n')
info('### Success in INVALID Rest PUT for Interfaces id ###\n')
def test_single_column_retrieval(self):
# Test Setup
test_title = "- Single column retrieval in GET request"
info(TEST_START % test_title)
keys = ["name"]
appended_keys = self.get_keys_to_retrieve(keys)
new_path = self.path + "keys=" + appended_keys
# 1 - Query Resource
response, response_data = execute_request(
self.path, "GET", None, self.switch_ip, True,
xtra_header=self.cookie_header)
status_code = response.status
assert status_code == httplib.OK, "Wrong status code %s " % status_code
complete_data_rows = get_json(response_data)
response, response_data = execute_request(
new_path, "GET", None, self.switch_ip, True,
xtra_header=self.cookie_header)
status_code = response.status
assert status_code == httplib.OK, "Wrong status code %s " % status_code
data_rows = get_json(response_data)
info("### Data successfully retrieved. Status code 200 OK ###\n")
# Test
# 2 - Validate that data exist in rows by keys retrieval
result = \
self.validate_retrieved_data_by_keys(complete_data_rows,
data_rows, keys)
assert result is True, "Wrong data length: %s <--> %s\n" \
% (len(complete_data_rows), len(data_rows))
info("### Retrieved data validated ###\n")
# Test Teardown
info(TEST_END % test_title)
def test_recursive_get_depth_first_level(self):
specific_interface_path = self.PATH + "/50-1"
depth_interface_path = self.PATH + "?depth=1;name=50-1"
status_code, expected_data = execute_request(
specific_interface_path,
"GET",
None,
self.SWITCH_IP,
xtra_header=self.cookie_header)
status_code, response_data = execute_request(
depth_interface_path,
"GET",
None,
self.SWITCH_IP,
xtra_header=self.cookie_header)
json_expected_data = self.get_json(expected_data)
json_data = self.get_json(response_data)[0]
info("\n########## Test to Validate recursive GET Interface 50-1 "
"depth=1 request ##########\n")
assert status_code == httplib.OK, "Wrong status code %s " % status_code
info("### Status code is OK ###\n")
assert self.validate_keys_complete_object(json_data)
info("### Validated first level of depth ###\n")
json_expected_data = json_expected_data["status"]
json_data = json_data["status"]
assert self.validate_keys_inner_object(json_data, json_expected_data)
info("########## End Test to Validate recursive GET Interface 50-1 "
"depth=1 request ##########\n")
def logs_with_offset_limit_negative_test_cases(self):
info("\n########## Test to Validate logs with negative pagination" +
" parameters ##########\n")
self.LOGS_PATH = (self.PATH + "?offset=1&limit=-1")
status_code, response_data = execute_request(
self.LOGS_PATH, "GET", None, self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.BAD_REQUEST, "Wrong status code %s " \
% status_code
info("### Status code for negative limit is okay ###\n")
self.LOGS_PATH = (self.PATH + "?offset=-1&limit=-1")
status_code, response_data = execute_request(
self.LOGS_PATH, "GET", None, self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.BAD_REQUEST, "Wrong status code %s " \
% status_code
info("### Status code for negative offset and limit is OK ###\n")
self.LOGS_PATH = (self.PATH + "?offset=-1&limit=1")
status_code, response_data = execute_request(
self.LOGS_PATH, "GET", None, self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.BAD_REQUEST, "Wrong status code %s " \
% status_code
info("### Status code for negative offset is okay ###\n")
info("\n########## End Test to Validate logs with negative" +
" pagination parameters ##########\n")
def test_ecmp_enable(self):
# enable ecmp
ECMP_PATCH[0]["value"]["enabled"] = \
ECMP_PATCH[0]["value"].pop(ECMP_PATCH[0]["value"].keys()[0])
ECMP_PATCH[0]["value"]["enabled"] = TRUE
status_code, response_data = execute_request(
self.PATH,
"PATCH",
json.dumps(ECMP_PATCH),
self.SWITCH_IP,
False,
xtra_header=self.cookie_header)
assert status_code == httplib.NO_CONTENT, "Error patching a ecmp " \
"enable Status code: %s Response data: %s " % (status_code,
response_data)
info("### Enable ECMP Patched. Status code is 204 NO CONTENT ###\n")
# Verify data
status_code, response_data = execute_request(
self.PATH,
"GET",
None,
self.SWITCH_IP,
False,
xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Failed to query ecmp config"
json_data = get_json(response_data)
assert json_data["configuration"]["ecmp_config"]["enabled"] == TRUE,\
"ECMP enable failed"
info("### ECMP enable validated ###\n")
def verify_post_bgp_neighbors(self):
info("\n#####################################################\n")
info("# Testing POST for BGP_Neighbors #")
info("\n#####################################################\n")
status_code, response_data = execute_request(
self.path_bgp, "POST", json.dumps(_DATA),
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
info('\nPOST BGP router with the asn: ' +
str(_DATA['configuration']['asn']) + ' passed successfully')
status_code, response_data = execute_request(
self.path_bgp_neighbors, "POST",
json.dumps(_DATA_BGP_NEIGHBORS), self.SWITCH_IP, False,
xtra_header=self.cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
info('\nPOST BGP neighbors with the ip: ' + str(_DATA_BGP_NEIGHBORS
['configuration']['ip_or_group_name']) + ' passed successfully\n')
status_code, response_data = execute_request(
self.path_bgp_neighbors_id, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s " % status_code
d = get_json(response_data)
assert d['configuration'] == _DATA_BGP_NEIGHBORS_COPY['configuration']
info('Post test passed successfully')
def modify_port_with_depth(self):
info("\n########## Test to Validate Modify Port with depth "
"##########\n")
# 1 - Query port
status_code, response_data = execute_request(
self.PORT_PATH, "GET", None, self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Port %s doesn't exists" % \
self.PORT_PATH
pre_put_get_data = {}
try:
pre_put_get_data = json.loads(response_data)
except:
assert False, "Malformed JSON"
info("### Query Port %s ###\n" % response_data)
# 2 - Modify data
put_data = pre_put_get_data["configuration"]
put_data["ip4_address"] = "192.168.1.2"
status_code, response_data = execute_request(
self.PORT_PATH + "?depth=1", "PUT",
json.dumps({'configuration':put_data}), self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.BAD_REQUEST, \
"Unexpected status code. Received: %s Response data: %s " % \
(status_code, response_data)
info("### Port Not Modified. Status code is 400 BAD REQUEST ###\n")
info("\n########## End Test to Validate Modify Port ##########\n")
def successful_login(self):
'''
This verifies Login is successful when using correct data
'''
test_title = "successful Login"
info(TEST_START % test_title)
data = {'username': DEFAULT_USER, 'password': DEFAULT_PASSWORD}
# Attempt Login
info("Attempting login with correct data...")
response, response_data = execute_request(LOGIN_URI, "POST",
urllib.urlencode(data),
self.SWITCH_IP, True,
HEADERS)
assert response.status == httplib.OK, ("Login POST not successful, " +
"code: %s " % response.status)
info(" All good.\n")
# Get cookie header
cookie_header = {'Cookie': response.getheader('set-cookie')}
time.sleep(2)
# Verify Login was successful
info("Verifying Login was successful...")
status_code, response_data = execute_request(LOGIN_URI, "GET", None,
self.SWITCH_IP, False,
cookie_header)
assert status_code == httplib.OK, ("Login GET not successful, " +
"code: %s " % status_code)
info(" All good.\n")
info(TEST_END % test_title)
def dc_test_custom_validator_valid_put(self):
info("### Testing valid DC PUT request ###\n")
status_code, response_data = execute_request(
self.dc_put_url, "PUT", json.dumps(DC_PUT_DATA),
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.OK, ("Wrong status code %s " %
status_code)
info("### Successfully executed PUT for url=%s ###\n" %
self.dc_put_url)
status_code, response_data = execute_request(
self.dc_put_url, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.OK, ("Wrong status code %s " %
status_code)
d = get_json(response_data)
assert d['Interface']['49'] == DC_PUT_DATA['Interface']['49'], \
'Failed in checking the GET METHOD JSON response validation for \
Interface 49'
assert d['Port']['p1'] == DC_PUT_DATA['Port']['p1'], \
'Failed in checking the GET METHOD JSON response validation for \
Port p1'
info("### Received successful HTTP status code ###\n")
def verify_post_bgp_neighbors(self):
info("\n#####################################################\n")
info("# Testing POST for BGP_Neighbors #")
info("\n#####################################################\n")
status_code, response_data = execute_request(
self.path_bgp, "POST", json.dumps(_DATA),
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
info('\nPOST BGP router with the asn: ' +
str(_DATA['configuration']['asn']) + ' passed successfully')
status_code, response_data = execute_request(
self.path_bgp_neighbors, "POST",
json.dumps(_DATA_BGP_NEIGHBORS), self.SWITCH_IP, False,
xtra_header=self.cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
info('\nPOST BGP neighbors with the ip: ' + str(_DATA_BGP_NEIGHBORS
['configuration']['ip_or_group_name']) + ' passed successfully\n')
status_code, response_data = execute_request(
self.path_bgp_neighbors_id, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s " % status_code
d = get_json(response_data)
assert d['configuration'] == _DATA_BGP_NEIGHBORS_COPY['configuration']
info('Post test passed successfully')
def test_ecmp_reshash_disable(self):
# disable ecmp resilient hash
ECMP_PATCH[0]["value"]["resilient_hash_enabled"] = \
ECMP_PATCH[0]["value"].pop(ECMP_PATCH[0]["value"].keys()[0])
ECMP_PATCH[0]["value"]["resilient_hash_enabled"] = FALSE
status_code, response_data = execute_request(
self.PATH,
"PATCH",
json.dumps(ECMP_PATCH),
self.SWITCH_IP,
False,
xtra_header=self.cookie_header)
assert status_code == httplib.NO_CONTENT, \
"Error patching ecmp resilient hash disable Status code: \
%s Response data: %s " % (status_code, response_data)
info("### Disable Resilient Hash ECMP Patched. Status code is 204 "
"NO CONTENT ###\n")
# Verify data
status_code, response_data = execute_request(
self.PATH,
"GET",
None,
self.SWITCH_IP,
False,
xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Failed to query ecmp config"
json_data = get_json(response_data)
assert json_data[
"configuration"]["ecmp_config"]["resilient_hash_enabled"]\
== FALSE, "ECMP resilient hash disable failed"
info("### ECMP resilient hash disable validated ###\n")
def verify_startup_config(self):
info('''"\n########## Verify startup config writes and reads the
config to startup config db ##########\n"''')
src_path = os.path.dirname(os.path.realpath(__file__))
src_file = os.path.join(src_path, 'json.data')
path = '/rest/v1/system' + '/full-configuration?type=startup'
with open(src_file) as data_file:
_data = json.loads(data_file.read())
status_code, response_data = execute_request(
path,
"PUT",
json.dumps(_data),
self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.OK
status_code, response_data = execute_request(
path, "GET", None, self.SWITCH_IP, xtra_header=self.cookie_header)
content = json.loads(response_data)
assert status_code == httplib.OK
assert ordered(content) == ordered(_data)
info("\n### Startup config write & read were successful ###\n")
def change_password_successful_change(self):
'''
Assuming the user is logged in, attempt to change
their password with all correct data
'''
test_title = "attempt password change with correct data"
info(TEST_START % test_title)
# Initialize test data
newpassword = '******'
data = {
'configuration': {
'password': DEFAULT_PASSWORD,
'new_password': newpassword
}
}
# Attempt to change password
status_code, response_data = \
execute_request(ACCOUNT_URI, "PUT", json.dumps(data),
self.SWITCH_IP, xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s " % status_code
# Attempt a login with the new password
self.cookie_header = login(self.SWITCH_IP, password=newpassword)
# Change password back to default
data['configuration']['password'] = newpassword
data['configuration']['new_password'] = DEFAULT_PASSWORD
status_code, response_data = \
execute_request(ACCOUNT_URI, "PUT", json.dumps(data),
self.SWITCH_IP, xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s " % status_code
info(TEST_END % test_title)
def test_interfaces_id(self):
status_code, response_data = execute_request(
self.url, "PUT", json.dumps(DATA),
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.OK, ("Wrong status code %s " %
status_code)
info('### Success in executing the rest command "PUT" for url: ' +
self.url + ' ###\n')
info('### Success in Rest PUT Interfaces id ###\n')
status_code, response_data = execute_request(
self.url, "GET", None, self.SWITCH_IP, False,
xtra_header=self.cookie_header)
assert status_code == httplib.OK, ("Wrong status code %s " %
status_code)
d = get_json(response_data)
assert d['configuration'] == DATA['configuration']
info('### Success in executing the rest command "GET" for url: ' +
self.url + ' ###\n')
info('### Success in Rest GET Interfacesid ###\n')
assert d['configuration']['name'] == 'bridge_normal', 'Failed in checking the \
GET METHOD JSON response validation for Interface name'
info('### Success in Rest GET system for Interface name ###\n')
status_code, response_data = execute_request(
self.url, "DELETE", json.dumps(DATA), self.SWITCH_IP, False,
xtra_header=self.cookie_header)
assert status_code == httplib.NO_CONTENT, ("Wrong status code %s " %
status_code)
info('### Success in executing the rest command "DELETE" for url: ' +
self.url + ' ###\n')
info('### Success in executing the rest command \
"DELETE for url=/rest/v1/system/interfaces/bridge_normal" ###\n')
info('### Success in Rest DELETE Interfacesid ###\n')
status_code, response_data = execute_request(
self.url, "GET", None, self.SWITCH_IP, False,
xtra_header=self.cookie_header)
assert status_code == httplib.NOT_FOUND, ("Wrong status code %s " %
status_code)
info('### Success in executing the rest command" "GET" as not \
expected for url: ' + self.url + ' ###\n')
info('### Success in Rest Checking http code 404 for GET method \
#once DELETED Interfacesid ###\n')
def delete_fake_vlan_if_exists(self, vlan_name):
info("\n### Deleting VLAN %s ###\n" % vlan_name)
path = self.vlan_path + "/" + vlan_name
status_code, response_data = execute_request(
path, "GET", None, self.switch_ip, xtra_header=self.cookie_header)
if status_code == httplib.OK:
status_code, response_data = execute_request(
path, "DELETE", None, self.switch_ip,
xtra_header=self.cookie_header)
assert status_code == httplib.NO_CONTENT, "VLAN deleted" % path
def logs_with_since_negative_test_cases(self):
info("\n########## Test to Validate negative test cases for logs" +
" with since timestamp ##########\n")
since_test = "0000-00-00%2000:00:00"
self.LOGS_PATH = self.PATH + "?since=%s&offset=%s&limit=%s" \
% (since_test, OFFSET_TEST, LIMIT_TEST)
status_code, response_data = execute_request(
self.LOGS_PATH,
"GET",
None,
self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.BAD_REQUEST, "Wrong status code %s " \
% status_code
info("### Status code for since 0000-00-00 00:00:00 "
"case is okay ###\n")
since_test = "2050-01-01%2001:00:00"
self.LOGS_PATH = self.PATH + "?since=%s&offset=%s&limit=%s" \
% (since_test, OFFSET_TEST, LIMIT_TEST)
status_code, response_data = execute_request(
self.LOGS_PATH,
"GET",
None,
self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s "\
% status_code
info("### Status code for since 2050-01-01 01:00:00 case is OK ###\n")
assert "Empty logs" in response_data, "Response data is empty"
info("### Response data returned for empty logs returned fine ###\n")
since_test = "-1%20hour%20ago"
self.LOGS_PATH = self.PATH + "?since=%s&offset=%s&limit=%s" \
% (since_test, OFFSET_TEST, LIMIT_TEST)
status_code, response_data = execute_request(
self.LOGS_PATH,
"GET",
None,
self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.BAD_REQUEST, "Wrong status code %s "\
% status_code
info("### Status code for since parameter with negative "
"value is okay ###\n")
info("\n########## End Test to Validate negative test case for logs" +
" with since timestamp ##########\n")
def create_test_port(request):
switch_ip = request.cls.test_var.SWITCH_IP
port_path = request.cls.test_var.PORT_PATH
default_port_path = request.cls.test_var.DEFAULT_PORT_PATH
test_port_path = request.cls.test_var.TEST_PORT_PATH
test_port_name = test_port_path.split("/")[-1]
# Login with default authorized user
cookie_header = login(switch_ip)
# Get default port data
status_code, response_data = \
execute_request(default_port_path, "GET",
None, switch_ip, xtra_header=cookie_header)
assert status_code == httplib.OK, "Could not get default port data, " + \
"status code: %s, data: %s" % (status_code, response_data)
data = get_json(response_data)
assert 'configuration' in data, "Corrupt default port data"
data['configuration']['name'] = test_port_name
data = {
'configuration': data['configuration'],
"referenced_by": [{
"uri": "/rest/v1/system/bridges/bridge_normal"
}]
}
# Save the port data
request.cls.test_var.port_data = data
# Create the test port
status_code, response_data = \
execute_request(port_path, "POST", json.dumps(data),
switch_ip, xtra_header=cookie_header)
assert status_code == httplib.CREATED, "Unable to create test port, " + \
"Status code: %s Response data: %s " % (status_code, response_data)
def fin():
status_code, response_data = \
execute_request(test_port_path, "DELETE", None,
switch_ip, xtra_header=cookie_header)
assert status_code in [httplib.NO_CONTENT, httplib.NOT_FOUND], \
"Unable to delete test port. Status code: %s Response data: %s" % \
(status_code, response_data)
request.addfinalizer(fin)
def test(self):
data = """
{
"configuration": {
"name": "fake_vlan_1",
"id": 2,
"description": "test vlan",
"admin": ["up"],
"other_config": {},
"external_ids": {}
}
}
"""
info("\n########## Executing POST to /system/bridges ##########\n")
info("Testing Path: %s\n" % self.vlan_path)
response_status, response_data = execute_request(
self.vlan_path,
"POST",
data,
self.switch_ip,
xtra_header=self.cookie_header)
assert response_status == httplib.CREATED, \
"Response status received: %s\n" % response_status
info("Response status received: \"%s\"\n" % response_status)
assert response_data is "", \
"Response data received: %s\n" % response_data
info("Response data received: %s\n" % response_data)
# Create duplicated
response_status, response_data = execute_request(
self.vlan_path,
"POST",
data,
self.switch_ip,
xtra_header=self.cookie_header)
assert response_status == httplib.BAD_REQUEST, \
"Response status received: %s\n" % response_status
info("Response status received: \"%s\"\n" % response_status)
assert response_data is not "", \
"Response data received: %s\n" % response_data
info("Response data received: %s\n" % response_data)
info("########## Executing POST to test duplicated VLAN DONE "
"##########\n")
def post_setup(self, cookie_header=None):
if cookie_header is None:
cookie_header = login(self.SWITCH_IP)
status_code, response_data = execute_request(
self.path_bgp, "POST", json.dumps(_DATA),
self.SWITCH_IP, False, xtra_header=cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
status_code, response_data = execute_request(
self.path_bgp_neighbors, "POST",
json.dumps(_DATA_BGP_NEIGHBORS), self.SWITCH_IP, False,
xtra_header=cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
def post_setup(self, cookie_header=None):
if cookie_header is None:
cookie_header = login(self.SWITCH_IP)
status_code, response_data = execute_request(
self.path_bgp, "POST", json.dumps(_DATA),
self.SWITCH_IP, False, xtra_header=cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
status_code, response_data = execute_request(
self.path_bgp_neighbors, "POST",
json.dumps(_DATA_BGP_NEIGHBORS), self.SWITCH_IP, False,
xtra_header=cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
def test_post_vlan_etag_match(self):
info(TEST_START % "POST VLAN with matching Etag")
# 1 - Query Resource
cond_path = self.vlan_path + self.config_selector
etag, pre_put_get_data = self.get_etag_and_data(cond_path)
# Fill Vlan data
fake_vlan_name = "VLAN3"
vlan_id = 3
data = FAKE_VLAN_DATA % {"name": fake_vlan_name, "id": vlan_id}
# Try to create the resource using a valid etag
headers = {"If-Match": etag}
headers.update(self.cookie_header)
status_code, response_data = execute_request(
cond_path, "POST", data, self.switch_ip, False, headers)
assert status_code == httplib.CREATED, "Error creating a VLAN using "\
"if-match option. Status code: %s Response data: %s "\
% (status_code, response_data)
info("### VLAN Created. Status code 201 CREATED ###\n")
# Delete created VLAN
self.delete_fake_vlan_if_exists(fake_vlan_name)
info(TEST_END % "POST VLAN with matching Etag")
def test(self):
data = {}
data["name"] = deepcopy(base_vlan_data)
data["id"] = deepcopy(base_vlan_data)
data["name"]["configuration"].pop("name")
data["id"]["configuration"].pop("id")
info("\n########## Executing POST test with missing fields "
"##########\n")
info("Testing Path: %s\n" % self.vlan_path)
for field, value in data.iteritems():
info("Testing missing field \"%s\" with value: %s\n" %
(field, value))
response_status, response_data = execute_request(
self.vlan_path,
"POST",
json.dumps(value),
self.switch_ip,
xtra_header=self.cookie_header)
assert response_status == httplib.BAD_REQUEST, \
"Response status received: %s\n" % response_status
info("Response status received: \"%s\"\n" % response_status)
assert response_data is not "", \
"Response data received: %s\n" % response_data
info("Response data received: %s\n" % response_data)
info("########## Executing POST test with missing fields DONE "
"##########\n")
def test_call_system_options(self):
info("\n########## Executing OPTIONS request on %s ##########\n" %
self.PATH)
# # Execute OPTIONS
response, json_string = execute_request(self.PATH,
"OPTIONS",
None,
self.SWITCH_IP,
True,
xtra_header=self.cookie_header)
assert response.status == httplib.OK, "OPTIONS request failed: {0} \
{1}".format(response.status, response.reason)
# # Check expected options are correct
# TODO change these to propper expected values after correct OPTIONS
# is implemented
expected_allow = ["DELETE", "GET", "OPTIONS", "POST", "PUT", "PATCH"]
response_allow = response.getheader("allow").split(", ")
assert expected_allow == response_allow, "OPTIONS: unexpected 'allow'\
options"
info("\n########## Finished executing OPTIONS request on %s \
##########\n" % self.PATH)
def logs_with_offset_limit(self):
info("\n########## Test to Validate logs with pagination parameters \
##########\n")
self.LOGS_PATH = (self.PATH + "?offset=%s&limit=%s") % \
(OFFSET_TEST, LIMIT_TEST)
status_code, response_data = execute_request(
self.LOGS_PATH, "GET", None, self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s " % status_code
info("### Status code is OK ###\n")
assert response_data is not None, "Response data is empty"
info("### Response data returned for logs are not empty ###\n")
json_data = get_json(response_data)
info("### JSON data is in good shape ###\n")
assert len(json_data) <= LIMIT_TEST, "Pagination for logs failed %s " \
% len(json_data)
info("### Pagination for logs works fine ###\n")
info("\n########## End Test to Validate logs with pagination" +
" paramteres ##########\n")
def delete_teardown(self, cookie_header=None):
if cookie_header is None:
cookie_header = login(self.SWITCH_IP)
status_code, response_data = execute_request(
self.path_bgp_neighbors_id, "DELETE", None,
self.SWITCH_IP, False, xtra_header=cookie_header)
assert (status_code == httplib.NO_CONTENT or
status_code == httplib.NOT_FOUND), ("Wrong status code %s " %
status_code)
status_code, response_data = execute_request(
self.path_id, "DELETE", None,
self.SWITCH_IP, False, xtra_header=cookie_header)
assert (status_code == httplib.NO_CONTENT or
status_code == httplib.NOT_FOUND), ("Wrong status code %s " %
status_code)
def test_call_system_get(self):
global response_global
info("\n########## Executing GET request on %s ##########\n" %
self.PATH)
# # Execute GET
response, json_string = execute_request(self.PATH,
"GET",
None,
self.SWITCH_IP,
True,
xtra_header=self.cookie_header)
assert response.status == httplib.OK, "GET request failed: {0} \
{1}".format(response.status, response.reason)
get_data = {}
try:
# A malformed json should throw an exception here
get_data = json.loads(json_string)
except:
assert False, "GET: Malformed JSON in response body"
# # Check data was received
assert get_data, "GET: Empty response"
assert type(get_data) is dict, "GET: Malformed response"
assert len(get_data) > 0, "GET: No data in response"
info("\n########## Finished executing GET request on %s ##########\n" %
self.PATH)
def test_delete_vlan_etag_match(self):
info(TEST_START % "DELETE VLAN with matching Etag")
# 1- Create Fake VLAN
fake_vlan_name = "VLAN3"
vlan_id = 3
create_fake_vlan(Test_IfMatchVlan.test_var.vlan_path,
Test_IfMatchVlan.test_var.switch_ip,
fake_vlan_name, vlan_id)
# 2- Query Resource
cond_path = self.vlan_path + "/" + fake_vlan_name\
+ self.config_selector
etag, pre_put_get_data = self.get_etag_and_data(cond_path)
# 3- Delete the vlan using the matching etag
headers = {"If-Match": etag}
headers.update(self.cookie_header)
status_code, response_data = execute_request(
cond_path, "DELETE", None, self.switch_ip, False, headers)
assert status_code == httplib.NO_CONTENT, "Error deleting VLAN using "\
"valid etag Status code: %s Response data: %s " % \
(status_code, response_data)
info("### VLAN deleted. Status code NOT CONTENT 204 ###\n")
info(TEST_END % "DELETE VLAN with matching Etag")
def test_post_vlan_etag_not_match(self):
info(TEST_START % "POST VLAN with not matching Etag")
# 1 - Query Resource
cond_path = self.vlan_path + self.config_selector
etag, pre_put_get_data = self.get_etag_and_data(cond_path)
# Set wrong etag
if etag:
etag = etag[::-1]
else:
etag = '"abcdef"'
# Fill Vlan data
fake_vlan_name = "VLAN3"
vlan_id = 3
data = FAKE_VLAN_DATA % {"name": fake_vlan_name, "id": vlan_id}
# Try to create the resource using a invalid etag
headers = {"If-Match": etag}
headers.update(self.cookie_header)
status_code, response_data = execute_request(
cond_path, "POST", data, self.switch_ip, False, headers)
assert status_code == httplib.PRECONDITION_FAILED, "Error creating "\
"using if-match using invalid etag. Status code: %s "\
"Response data: %s " % (status_code, response_data)
info("### VLAN No Created. Status code 412 Precondition Failed ###\n")
info(TEST_END % "POST VLAN with not matching Etag")
def test(self):
path = "%s/%s" % (self.vlan_path, self.vlan_name)
expected_configuration_data = {}
expected_configuration_data["name"] = "%s" % self.vlan_name
expected_configuration_data["id"] = 2
expected_configuration_data["description"] = "test_vlan"
expected_configuration_data["admin"] = "up"
#expected_configuration_data["other_config"] = {}
#expected_configuration_data["external_ids"] = {}
info("\n########## Executing GET to /system/bridges/{id}/vlans/ "
"{id} ##########\n")
info("Testing path: %s\n" % path)
response_status, response_data = execute_request(
path, "GET", None, self.switch_ip, xtra_header=self.cookie_header)
expected_response = json.loads(response_data)
assert response_status == httplib.OK, \
"Response status received: %s\n" % response_status
info("Response status received %s" % response_status)
assert compare_dict(expected_response["configuration"],
expected_configuration_data), \
"Response data received: %s\n" % response_data
info("########## Executing GET to /system/bridges/{id}/vlans/{id} "
"DONE ##########\n")
def delete_teardown(self, cookie_header=None):
if cookie_header is None:
cookie_header = login(self.SWITCH_IP)
status_code, response_data = execute_request(
self.path_bgp_neighbors_id, "DELETE", None,
self.SWITCH_IP, False, xtra_header=cookie_header)
assert (status_code == httplib.NO_CONTENT or
status_code == httplib.NOT_FOUND), ("Wrong status code %s " %
status_code)
status_code, response_data = execute_request(
self.path_id, "DELETE", None,
self.SWITCH_IP, False, xtra_header=cookie_header)
assert (status_code == httplib.NO_CONTENT or
status_code == httplib.NOT_FOUND), ("Wrong status code %s " %
status_code)
def update_bridge_ports(self, switch, port, action):
# action will add or remove this port from the existing ports
patch = [copy.deepcopy(PATCH_PRT)]
new_data = copy.deepcopy(PATCH_PRT)
# Get existing bridge ports list
ports = self.get_bridge_ports(switch)
# info("### Bridge Ports ".join(ports))
entry = "/rest/v1/system/ports/" + port
if action == ADD:
if entry not in ports:
ports.append("/rest/v1/system/ports/" + port)
new_data["value"] = ports
else:
if entry in ports:
ports.remove("/rest/v1/system/ports/" + port)
new_data["value"] = ports
patch.append(new_data)
status_code, response_data = execute_request(
self.PATH_BRIDGE_NORMAL, "PATCH",
json.dumps(patch),
switch, False, xtra_header=self.cookie_header)
assert status_code == httplib.NO_CONTENT, "Error update Ports" \
+ " code: %s Response data: %s " % (status_code, response_data)
info("### Bridge Port " + switch + " Status 204 NO CONTENT ###\n")
def unauthorized_user_login_attempt(self):
'''
This verifies that you can't login with
a user that has no REST login permissions.
Current login permissions include
READ_SWITCH_CONFIG and WRITE_SWITCH_CONFIG.
Currently, the only users that do not have
either of these permissions are any user from
the ops_admin group
'''
test_title = "login attempt by unauthorized user"
info(TEST_START % test_title)
data = {'username': '******', 'password': '******'}
# Attempt Login
info("Attempting login with an unauthorized user...")
status_code, response_data = execute_request(LOGIN_URI, "POST",
urllib.urlencode(data),
self.SWITCH_IP, False,
HEADERS)
assert status_code == httplib.UNAUTHORIZED, "Wrong status code " + \
"when attempting login by an unauthorized user: %s " % status_code
info(" All good.\n")
info(TEST_END % test_title)
def logs_with_offset_None(self):
info("\n########## Test to Validate logs with no offset for" +
" pagination ##########\n")
offset_test = None
self.LOGS_PATH = self.PATH + "?limit=%s" % LIMIT_TEST
status_code, response_data = execute_request(
self.LOGS_PATH, "GET", None, self.SWITCH_IP,
xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s " % status_code
info("### Status code is OK ###\n")
assert response_data is not None, "Response data is empty"
info("### Response data returned is not empty ###\n")
json_data = get_json(response_data)
info("### JSON data is in good shape ###\n")
assert len(json_data) <= LIMIT_TEST, "Pagination for logs failed %s " \
% len(json_data)
info("### Pagination for logs works fine ###\n")
info("\n########## End Test to Validate logs with no offset for" +
" pagination ##########\n")
def verify_delete_bgp_neighbors(self):
info("\n#####################################################\n")
info("# Testing DELETE for BGP_Neighbors #")
info("\n#####################################################\n")
status_code, response_data = execute_request(
self.path_bgp_neighbors_id, "DELETE", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.NO_CONTENT, ("Wrong status code %s " %
status_code)
status_code, response_data = execute_request(
self.path_bgp_neighbors_id, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.NOT_FOUND, ("Wrong status code %s " %
status_code)
info('DELETE passed successfully')
info("\n")
def verify_delete_bgp_routers(self):
info("\n#####################################################\n")
info("# Testing DELETE for BGP_Routers #")
info("\n#####################################################\n")
# DELETE the bgp_router
status_code, response_data = execute_request(
self.path_id, "DELETE", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.NO_CONTENT, ("Wrong status code %s " %
status_code)
# GET after deleting the bgp_router
status_code, response_data = execute_request(
self.path_id, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.NOT_FOUND, ("Wrong status code %s " %
status_code)
info('Successful\n')
def verify_post_bgp_routers(self):
info("\n#####################################################\n")
info("# Testing POST for BGP_Routers #")
info("\n#####################################################\n")
status_code, response_data = execute_request(
self.path_bgp, "POST", json.dumps(_DATA),
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.CREATED, ("Wrong status code %s " %
status_code)
status_code, response_data = execute_request(
self.path_id, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.OK, ("Wrong status code %s " %
status_code)
d = get_json(response_data)
assert d['configuration'] == _DATA_COPY['configuration']
info('Successful')
def verify_put_bgp_routers(self):
info("\n#####################################################\n")
info("# Testing PUT for BGP_Routers #")
info("\n#####################################################\n")
_DATA_COPY['configuration']['networks'] = ["10.10.1.0/24"]
status_code, response_data = execute_request(
self.path_id, "PUT", json.dumps(_DATA_COPY),
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.OK, ("Wrong status code %s " %
status_code)
status_code, response_data = execute_request(
self.path_id, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
status_code == httplib.OK, ("Wrong status code %s " %
status_code)
content = response_data
d = get_json(content)
assert d['configuration'] == _DATA_COPY['configuration']
info('Successful')
def verify_put_bgp_neighbors(self):
info("\n#####################################################\n")
info("# Testing PUT for BGP_Neighbors #")
info("\n#####################################################\n")
_DATA_BGP_NEIGHBORS_COPY['configuration']['description'] = \
'BGP_Neighbors'
status_code, response_data = execute_request(
self.path_bgp_neighbors_id, "PUT",
json.dumps(_DATA_BGP_NEIGHBORS_COPY), self.SWITCH_IP, False,
xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s " % status_code
status_code, response_data = execute_request(
self.path_bgp_neighbors_id, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
assert status_code == httplib.OK, "Wrong status code %s " % status_code
d = get_json(response_data)
d['configuration'].pop('capability', None)
assert d['configuration'] == _DATA_BGP_NEIGHBORS_COPY['configuration']
info('PUT passed successfully')
def verify_get_bgp_routers(self):
info("\n#####################################################\n")
info("# Testing GET for BGP_Routers #")
info("\n#####################################################\n")
status_code, response_data = execute_request(
self.path_id, "GET", None,
self.SWITCH_IP, False, xtra_header=self.cookie_header)
status_code == httplib.OK, ("Wrong status code %s " %
status_code)
d = get_json(response_data)
assert d['configuration'] == _DATA_COPY['configuration']
info('GET for BGP router with asn: ' +
str(_DATA['configuration']['asn']) + ' passed successfully')
