def perform_tests(servername, username, count=0):
logging.info(
'perform metering_label_rule tests, server: %s, user: %s' %
(servername, username))
tester = MeteringLabelRule(servername, username)
utils.assert_status(tester.get_metering_label_rules(), 200)
metering_label_rule_one = tester.create_metering_label_rule(
change_id(METERING_LABEL_RULE_ONE, count))
utils.assert_status(metering_label_rule_one, 201)
if metering_label_rule_one.status_code == 201:
metering_label_rule_one_id = json.loads(
metering_label_rule_one.text)['metering_label_rule']['id']
utils.assert_status(
tester.get_metering_label_rule(metering_label_rule_one_id),
200)
utils.assert_status(
tester.delete_metering_label_rule(
change_id(METERING_LABEL_RULE_ONE,
count)['metering_label_rule']['id']), 204)
utils.assert_status(
tester.get_metering_label_rule(
change_id(METERING_LABEL_RULE_ONE,
count)['metering_label_rule']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info('perform network tests, server: %s, user: %s' % (servername, username))
tester = Network(servername, username)
utils.assert_status(tester.get_networks(), 200)
network_one = tester.create_network(change_id(NETWORK_ONE, count))
utils.assert_status(network_one, 201)
if network_one.status_code == 201:
network_one_id = json.loads(network_one.text)['network']['id']
utils.assert_status(tester.get_network(network_one_id), 200)
utils.assert_status(tester.create_network(change_id(NETWORK_DEFAULT, count)), 201)
utils.assert_status(tester.update_network(change_id(NETWORK_UPDATE['network'], count)['network']['id'],
change_id(NETWORK_UPDATE['network'], count)), 200)
if count == 0:
# utils.assert_status(tester.create_network(change_id(NETWORK_EXTERNAL, count)), 201)
utils.assert_status(tester.create_network(NETWORKS_BULK), 201)
utils.assert_status(tester.delete_network(NETWORKS_BULK['networks'][0]['id']), 204)
utils.assert_status(tester.get_network(NETWORKS_BULK['networks'][0]['id']), 404)
networks = tester.get_networks()
for net in json.loads(networks.text)['networks']:
utils.assert_status(tester.delete_network(net['id']), 204)
def perform_tests(servername, username, count=0):
logging.info('perform sfc_port_pair tests, server: %s, user: %s' %
(servername, username))
tester = SFCPortPair(servername, username)
utils.assert_status(tester.get_sfc_port_pairs(), 200)
sfc_port_pair_one = tester.create_sfc_port_pair(
change_id(SFC_PORT_PAIR_ONE, count))
utils.assert_status(sfc_port_pair_one, 201)
if sfc_port_pair_one.status_code == 201:
sfc_port_pair_one_id = json.loads(
sfc_port_pair_one.text)['portpair']['id']
utils.assert_status(tester.get_sfc_port_pair(sfc_port_pair_one_id),
200)
utils.assert_status(
tester.update_sfc_port_pair(
change_id(SFC_PORT_PAIR_UPDATE['portpair'],
count)['portpair']['id'],
change_id(SFC_PORT_PAIR_UPDATE['portpair'], count)), 200)
utils.assert_status(
tester.delete_sfc_port_pair(
change_id(SFC_PORT_PAIR_ONE, count)['portpair']['id']), 204)
utils.assert_status(
tester.get_sfc_port_pair(
change_id(SFC_PORT_PAIR_ONE, count)['portpair']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info('perform trunk tests, server: %s, user: %s' %
(servername, username))
tester = Trunk(servername, username)
utils.assert_status(tester.get_trunks(), 200)
trunk_one = tester.create_trunk(change_id(TRUNK_ONE, count))
utils.assert_status(trunk_one, 201)
if trunk_one.status_code == 201:
trunk_one_id = json.loads(trunk_one.text)['trunk']['id']
utils.assert_status(tester.get_trunk(trunk_one_id), 200)
utils.assert_status(
tester.create_trunk(change_id(TRUNK_DEFAULT, count)), 201)
utils.assert_status(
tester.update_trunk(
change_id(TRUNK_UPDATE['trunk'], count)['trunk']['id'],
change_id(TRUNK_UPDATE['trunk'], count)), 200)
if count == 0:
utils.assert_status(tester.create_trunk(TRUNKS_BULK), 201)
utils.assert_status(
tester.delete_trunk(TRUNKS_BULK['trunks'][0]['id']), 204)
utils.assert_status(
tester.get_trunk(TRUNKS_BULK['trunks'][0]['id']), 404)
trunks = tester.get_trunks()
for trunk in json.loads(trunks.text)['trunks']:
utils.assert_status(tester.delete_trunk(trunk['id']), 204)
def perform_tests(servername, username, count=0):
logging.info('perform loadbalancer_pool tests, server: %s, user: %s' % (servername, username))
tester = LoadbalancerPool(servername, username)
utils.assert_status(tester.get_loadbalancer_pools(), 200)
loadbalancer_pool_one = tester.create_loadbalancer_pool(change_id(LOAD_BALANCER_POOL_ONE, count))
utils.assert_status(loadbalancer_pool_one, 201)
if loadbalancer_pool_one.status_code == 201:
loadbalancer_pool_one_id = json.loads(loadbalancer_pool_one.text)['pool']['id']
utils.assert_status(tester.get_loadbalancer_pool(loadbalancer_pool_one_id), 200)
utils.assert_status(tester.update_loadbalancer_pool(
change_id(LOAD_BALANCER_POOL_UPDATE['pool'], count)['pool']['id'],
change_id(LOAD_BALANCER_POOL_UPDATE['pool'], count)), 200)
utils.assert_status(tester.delete_loadbalancer_pool(change_id(LOAD_BALANCER_POOL_ONE, count)['pool']['id']),
204)
utils.assert_status(tester.get_loadbalancer_pool(change_id(LOAD_BALANCER_POOL_ONE, count)['pool']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info('perform gateway_connection tests, server: %s, user: %s' %
(servername, username))
tester = GatewayConnection(servername, username)
utils.assert_status(tester.get_gateway_connections(), 200)
gateway_connection_one = tester.create_gateway_connection(
change_id(GATEWAY_CONNECTION_ONE, count))
utils.assert_status(gateway_connection_one, 201)
if gateway_connection_one.status_code == 201:
gateway_connection_one_id = json.loads(
gateway_connection_one.text)['l2gateway_connection']['id']
utils.assert_status(
tester.get_gateway_connection(gateway_connection_one_id), 200)
gateway_connection_two = tester.create_gateway_connection(
change_id(GATEWAY_CONNECTION_TWO, count))
utils.assert_status(gateway_connection_two, 201)
if gateway_connection_two.status_code == 201:
gateway_connection_two_id = json.loads(
gateway_connection_two.text)['l2gateway_connection']['id']
utils.assert_status(
tester.get_gateway_connection(gateway_connection_two_id), 200)
utils.assert_status(
tester.delete_gateway_connection(
change_id(GATEWAY_CONNECTION_ONE,
count)['l2gateway_connection']['id']), 204)
utils.assert_status(
tester.get_gateway_connection(
change_id(GATEWAY_CONNECTION_ONE,
count)['l2gateway_connection']['id']), 404)
utils.assert_status(
tester.delete_gateway_connection(
change_id(GATEWAY_CONNECTION_TWO,
count)['l2gateway_connection']['id']), 204)
utils.assert_status(
tester.get_gateway_connection(
change_id(GATEWAY_CONNECTION_TWO,
count)['l2gateway_connection']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info(
'perform loadbalancer_health_monitor tests, server: %s, user: %s' %
(servername, username))
tester = LoadbalancerHealthMonitor(servername, username)
utils.assert_status(tester.get_loadbalancer_health_monitors(), 200)
loadbalancer_health_monitor_one = tester.create_loadbalancer_health_monitor(
change_id(LOAD_BALANCER_HEALTH_MONITOR_ONE, count))
utils.assert_status(loadbalancer_health_monitor_one, 201)
if loadbalancer_health_monitor_one.status_code == 201:
loadbalancer_health_monitor_one_id = json.loads(
loadbalancer_health_monitor_one.text)['healthmonitor']['id']
utils.assert_status(
tester.get_loadbalancer_health_monitor(
loadbalancer_health_monitor_one_id), 200)
utils.assert_status(
tester.update_loadbalancer_health_monitor(
change_id(LOAD_BALANCER_HEALTH_MONITOR_UPDATE['healthmonitor'],
count)['healthmonitor']['id'],
change_id(LOAD_BALANCER_HEALTH_MONITOR_UPDATE['healthmonitor'],
count)), 200)
utils.assert_status(
tester.delete_loadbalancer_health_monitor(
change_id(LOAD_BALANCER_HEALTH_MONITOR_ONE,
count)['healthmonitor']['id']), 204)
utils.assert_status(
tester.get_loadbalancer_health_monitor(
change_id(LOAD_BALANCER_HEALTH_MONITOR_ONE,
count)['healthmonitor']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info(
'perform sfc_flow_classifier tests, server: %s, user: %s' %
(servername, username))
tester = SFCFlowClassifier(servername, username)
utils.assert_status(tester.get_sfc_flow_classifiers(), 200)
sfc_flow_classifier_one = tester.create_sfc_flow_classifier(
change_id(SFC_FLOW_CLASSIFIER_ONE, count))
utils.assert_status(sfc_flow_classifier_one, 201)
if sfc_flow_classifier_one.status_code == 201:
sfc_flow_classifier_one_id = json.loads(
sfc_flow_classifier_one.text)['flowclassifier']['id']
utils.assert_status(
tester.get_sfc_flow_classifier(sfc_flow_classifier_one_id),
200)
utils.assert_status(
tester.update_sfc_flow_classifier(
change_id(SFC_FLOW_CLASSIFIER_UPDATE['flowclassifier'],
count)['flowclassifier']['id'],
change_id(SFC_FLOW_CLASSIFIER_UPDATE['flowclassifier'],
count)), 200)
utils.assert_status(
tester.delete_sfc_flow_classifier(
change_id(SFC_FLOW_CLASSIFIER_ONE,
count)['flowclassifier']['id']), 204)
utils.assert_status(
tester.get_sfc_flow_classifier(
change_id(SFC_FLOW_CLASSIFIER_ONE,
count)['flowclassifier']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info('perform gateway tests, server: %s, user: %s' %
(servername, username))
tester = Gateway(servername, username)
utils.assert_status(tester.get_gateways(), 200)
gateway_one = tester.create_gateway(change_id(GATEWAY_ONE, count))
utils.assert_status(gateway_one, 201)
if gateway_one.status_code == 201:
gateway_one_id = json.loads(gateway_one.text)['l2_gateway']['id']
utils.assert_status(tester.get_gateway(gateway_one_id), 200)
utils.assert_status(
tester.update_gateway(
change_id(GATEWAY_UPDATE['l2_gateway'],
count)['l2_gateway']['id'],
change_id(GATEWAY_UPDATE['l2_gateway'], count)), 200)
utils.assert_status(
tester.delete_gateway(
change_id(GATEWAY_ONE, count)['l2_gateway']['id']), 204)
utils.assert_status(
tester.get_gateway(
change_id(GATEWAY_ONE, count)['l2_gateway']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info('perform security_group_rule tests, server: %s, user: %s' % (servername, username))
tester = SecurityGroupRule(servername, username)
utils.assert_status(tester.get_security_group_rules(), 200)
security_group_rule_one = tester.create_security_group_rule(change_id(SECURITY_GROUP_RULE_ONE, count))
utils.assert_status(security_group_rule_one, 201)
if security_group_rule_one.status_code == 201:
security_group_rule_one_id = json.loads(security_group_rule_one.text)['security_group_rule']['id']
utils.assert_status(tester.get_security_group_rule(security_group_rule_one_id), 200)
utils.assert_status(tester.update_security_group_rule(
change_id(SECURITY_GROUP_RULE_UPDATE['security_group_rule'], count)['security_group_rule']['id'],
change_id(SECURITY_GROUP_RULE_UPDATE['security_group_rule'], count)), 200)
if count == 0:
utils.assert_status(tester.create_security_group_rule(SECURITY_GROUP_RULES_BULK), 201)
utils.assert_status(tester.delete_security_group_rule(
SECURITY_GROUP_RULES_BULK['security_group_rules'][0]['id']), 204)
utils.assert_status(tester.get_security_group_rule(
SECURITY_GROUP_RULES_BULK['security_group_rules'][0]['id']), 404)
security_group_rules = tester.get_security_group_rules()
for s in json.loads(security_group_rules.text)['security_group_rules']:
utils.assert_status(tester.delete_security_group_rule(s['id']), 204)
def perform_tests(servername, username, count=0):
tester = Router(servername, username)
router_one = tester.create_router(change_id(ROUTER_ONE, count))
utils.assert_status(router_one, 201)
if router_one.status_code == 201:
router_one_id = json.loads(router_one.text)['router']['id']
utils.assert_status(tester.get_router(router_one_id), 200)
if count == 0:
utils.assert_status(
tester.add_interface(ROUTER_ADD_INTERFACE['id'],
ROUTER_ADD_INTERFACE['interface']), 200)
utils.assert_status(
tester.add_interface(ROUTER_ADD_INTERFACE2['id'],
ROUTER_ADD_INTERFACE2['interface']), 200)
utils.assert_status(
tester.remove_interface(ROUTER_ADD_INTERFACE2['id'],
ROUTER_ADD_INTERFACE2['interface']),
200)
utils.assert_status(
tester.update_router(
change_id(ROUTER_UPDATE, count)['router']['id'],
change_id(ROUTER_UPDATE, count)), 200)
utils.assert_status(
tester.create_router(change_id(ROUTER_CREATED, count)), 201)
utils.assert_status(
tester.get_router(
change_id(ROUTER_CREATED, count)['router']['id']), 200)
utils.assert_status(
tester.delete_router(
change_id(ROUTER_CREATED, count)['router']['id']), 204)
utils.assert_status(
tester.get_router(
change_id(ROUTER_CREATED, count)['router']['id']), 404)
routers = tester.get_routers()
for r in json.loads(routers.text)['routers']:
utils.assert_status(tester.delete_router(r['id']), 204)
def perform_tests(servername, username, count=0):
logging.info('perform security_group tests, server: %s, user: %s' % (servername, username))
tester = SecurityGroup(servername, username)
utils.assert_status(tester.get_security_groups(), 200)
security_group_one = tester.create_security_group(change_id(SECURITY_GROUP_ONE, count))
utils.assert_status(security_group_one, 201)
if security_group_one.status_code == 201:
security_group_one_id = json.loads(security_group_one.text)['security_group']['id']
utils.assert_status(tester.get_security_group(security_group_one_id), 200)
utils.assert_status(tester.update_security_group
(change_id(SECURITY_GROUP_UPDATE['security_group'], count)['security_group']['id'],
change_id(SECURITY_GROUP_UPDATE['security_group'], count)), 200)
utils.assert_status(tester.delete_security_group(change_id(SECURITY_GROUP_ONE, count)['security_group']['id']),
204)
utils.assert_status(tester.get_security_group(change_id(SECURITY_GROUP_ONE, count)['security_group']['id']),
404)
def perform_tests(servername, username, count=0):
logging.info('perform subnet tests, server: %s, user: %s' %
(servername, username))
tester = Subnet(servername, username)
utils.assert_status(tester.get_subnets(), 200)
subnet = tester.create_subnet(change_id(SUBNET, count))
utils.assert_status(subnet, 201)
if subnet.status_code == 201:
subnet_id = json.loads(subnet.text)['subnet']['id']
utils.assert_status(tester.get_subnet(subnet_id), 200)
utils.assert_status(
tester.create_subnet(change_id(SUBNET_EXTERNAL, count)), 201)
utils.assert_status(
tester.update_subnet(
change_id(SUBNET_UPDATE['subnet'], count)['subnet']['id'],
change_id(SUBNET_UPDATE['subnet'], count)), 200)
if count == 0:
utils.assert_status(tester.create_subnet(SUBNETS_BULK), 201)
utils.assert_status(
tester.delete_subnet(SUBNETS_BULK['subnets'][0]['id']), 204)
utils.assert_status(
tester.get_subnet(SUBNETS_BULK['subnets'][0]['id']), 404)
subnets = tester.get_subnets()
for sub in json.loads(subnets.text)['subnets']:
utils.assert_status(tester.delete_subnet(sub['id']), 204)
def perform_tests(servername, username, count=0):
logging.info('perform vpn_service tests, server: %s, user: %s' % (servername, username))
tester = VpnService(servername, username)
utils.assert_status(tester.get_vpn_services(), 200)
vpn_service_one = tester.create_vpn_service(change_id(VPN_SERVICE_ONE, count))
utils.assert_status(vpn_service_one, 201)
if vpn_service_one.status_code == 201:
vpn_service_one_id = json.loads(vpn_service_one.text)['vpnservice']['id']
utils.assert_status(tester.get_vpn_service(vpn_service_one_id), 200)
utils.assert_status(tester.update_vpn_service(
change_id(VPN_SERVICE_UPDATE['vpnservice'], count)['vpnservice']['id'],
change_id(VPN_SERVICE_UPDATE['vpnservice'], count)), 200)
utils.assert_status(tester.delete_vpn_service(change_id(VPN_SERVICE_ONE, count)['vpnservice']['id']), 204)
utils.assert_status(tester.get_vpn_service(change_id(VPN_SERVICE_ONE, count)['vpnservice']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info('perform bgpvpn tests, server: %s, user: %s' %
(servername, username))
tester = Bgpvpn(servername, username)
utils.assert_status(tester.get_bgpvpns(), 200)
bgpvpn_one = tester.create_bgpvpn(change_id(BGPVPN_ONE, count))
utils.assert_status(bgpvpn_one, 201)
if bgpvpn_one.status_code == 201:
bgpvpn_one_id = json.loads(bgpvpn_one.text)['bgpvpn']['id']
utils.assert_status(tester.get_bgpvpn(bgpvpn_one_id), 200)
utils.assert_status(
tester.update_bgpvpn(
change_id(BGPVPN_UPDATE['bgpvpn'], count)['bgpvpn']['id'],
change_id(BGPVPN_UPDATE['bgpvpn'], count)), 200)
if count == 0:
utils.assert_status(tester.create_bgpvpn(BGPVPNS_BULK), 201)
utils.assert_status(
tester.delete_bgpvpn(BGPVPNS_BULK['bgpvpns'][0]['id']), 204)
utils.assert_status(
tester.get_bgpvpn(BGPVPNS_BULK['bgpvpns'][0]['id']), 404)
bgpvpns = tester.get_bgpvpns()
for bgp in json.loads(bgpvpns.text)['bgpvpns']:
utils.assert_status(tester.delete_bgpvpn(bgp['id']), 204)
def perform_tests(servername, username, count=0):
logging.info('perform qos_policy tests, server: %s, user: %s' %
(servername, username))
tester = QosPolicy(servername, username)
utils.assert_status(tester.get_qos_policys(), 200)
qos_policy_one = tester.create_qos_policy(
change_id(QOS_POLICY_ONE, count))
utils.assert_status(qos_policy_one, 201)
if qos_policy_one.status_code == 201:
qos_policy_one_id = json.loads(qos_policy_one.text)['policy']['id']
utils.assert_status(tester.get_qos_policy(qos_policy_one_id), 200)
utils.assert_status(
tester.update_qos_policy(
change_id(QOS_POLICY_UPDATE['policy'], count)['policy']['id'],
change_id(QOS_POLICY_UPDATE['policy'], count)), 200)
utils.assert_status(
tester.delete_qos_policy(
change_id(QOS_POLICY_ONE, count)['policy']['id']), 204)
utils.assert_status(
tester.get_qos_policy(
change_id(QOS_POLICY_ONE, count)['policy']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info('perform firewall_policy tests, server: %s, user: %s' %
(servername, username))
tester = FirewallPolicy(servername, username)
utils.assert_status(tester.get_firewall_policies(), 200)
firewall_policy_one = tester.create_firewall_policy(
change_id(FIREWALL_POLICY_ONE, count))
utils.assert_status(firewall_policy_one, 201)
if firewall_policy_one.status_code == 201:
firewall_policy_one_id = json.loads(
firewall_policy_one.text)['firewall_policy']['id']
utils.assert_status(
tester.get_firewall_policy(firewall_policy_one_id), 200)
utils.assert_status(
tester.update_firewall_policy(
change_id(FIREWALL_POLICY_UPDATE['firewall_policy'],
count)['firewall_policy']['id'],
change_id(FIREWALL_POLICY_UPDATE['firewall_policy'], count)),
200)
utils.assert_status(
tester.delete_firewall_policy(
change_id(FIREWALL_POLICY_ONE,
count)['firewall_policy']['id']), 204)
utils.assert_status(
tester.get_firewall_policy(
change_id(FIREWALL_POLICY_ONE,
count)['firewall_policy']['id']), 404)
def perform_tests(servername, username, count=0):
logging.info('perform port tests, server: %s, user: %s' %
(servername, username))
tester = Port(servername, username)
utils.assert_status(tester.get_ports(), 200)
port_one = tester.create_port(change_id(PORT_ONE, count))
utils.assert_status(port_one, 201)
if port_one.status_code == 201:
port_one_id = json.loads(port_one.text)['port']['id']
utils.assert_status(tester.get_port(port_one_id), 200)
utils.assert_status(tester.create_port(change_id(PORT_DEFAULT, count)),
201)
if count == 0:
utils.assert_status(tester.create_port(ROUTER_INTERFACE_PORT), 201)
utils.assert_status(tester.create_port(PORTS_BULK), 201)
utils.assert_status(
tester.delete_port(PORTS_BULK['ports'][0]['id']), 204)
utils.assert_status(tester.get_port(PORTS_BULK['ports'][0]['id']),
404)
utils.assert_status(
tester.update_port(
change_id(PORT_UPDATE['port'], count)['port']['id'],
change_id(PORT_UPDATE['port'], count)), 200)
ports = tester.get_ports()
for port in json.loads(ports.text)['ports']:
utils.assert_status(tester.delete_port(port['id']), 204)