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)