def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_environment = self.client.create_api_environment() self.api_equipment = self.client.create_api_equipment() self.api_pool = self.client.create_api_pool() self.api_environment_vip = self.client.create_api_environment_vip() self.api_vlan = self.client.create_api_vlan() self.api_network_ipv4 = self.client.create_api_network_ipv4() self.api_network_ipv6 = self.client.create_api_network_ipv6() self.api_ipv4 = self.client.create_api_ipv4() self.api_ipv6 = self.client.create_api_ipv6() self.api_pool_deploy = self.client.create_api_pool_deploy() self.ipsv4 = [{ 'id': 7, 'ip_formated': '192.168.104.2' }, { 'id': 8, 'ip_formated': '192.168.104.3' }, { 'id': 9, 'ip_formated': '192.168.104.4' }, { 'id': 10, 'ip_formated': '192.168.104.5' }, { 'id': 11, 'ip_formated': '192.168.104.6' }] self.id_env_of_pool = 10
def _control(request, *args, **kwargs): key = get_param_in_request(request, TOKEN) condition = "True" if not key: message = auth_messages.get("token_required") if request.is_ajax(): return HttpResponse(message, status=203) return HttpResponse( loader.render_to_string(TOKEN_INVALID, {"error": message})) if key not in cache: message = auth_messages.get("token_invalid") if request.is_ajax(): return HttpResponse(message, status=203) return HttpResponse( loader.render_to_string(TOKEN_INVALID, {"error": message})) # Get hash in cache data_from_cache = cache.get(key) user_hash = data_from_cache.get('user_hash') permissions = data_from_cache.get('permissions') #Check Has Permission if required_permissions: for perm in required_permissions: write_required = perm.get('write', False) read_required = perm.get('read', False) required_permission = perm.get('permission') permission = permissions.get(required_permission) write_permission = condition == permission.get('write') read_permission = condition == permission.get('read') if (write_required and not write_permission) or ( read_required and not read_permission): message = auth_messages.get('user_not_authorized') if request.is_ajax(): return HttpResponse(message, status=2003) return HttpResponse( loader.render_to_string(TOKEN_INVALID, {"error": message})) # Decrypt hash user = Encryption().Decrypt(user_hash) username, password, user_ldap = str(user).split("@") if user_ldap == "": client = ClientFactory(NETWORK_API_URL, username, password) else: client = ClientFactory(NETWORK_API_URL, username, password, user_ldap) kwargs["form_acess"] = ControlAcessForm(initial={"token": key}) kwargs["client"] = client # Execute method return func(request, *args, **kwargs)
def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_environment = self.client.create_api_environment() self.api_equipment = self.client.create_api_equipment() self.non_existent_eqpt = 1000
def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_environment_vip = self.client.create_api_environment_vip() self.api_network_ipv4 = self.client.create_api_network_ipv4() self.api_network_ipv6 = self.client.create_api_network_ipv6() self.api_environment = self.client.create_api_environment() self.api_vlan = self.client.create_api_vlan() self.non_existent_env_vip_id = 1111
def login(request): modal_auto_open = "false" if request.method == 'POST': form = LoginForm(request.POST) form_pass = PassForm() if form.is_valid(): try: client = ClientFactory( NETWORK_API_URL, NETWORK_API_USERNAME, NETWORK_API_PASSWORD) user = client.create_usuario().authenticate(form.cleaned_data[ 'username'], form.cleaned_data['password'], form.cleaned_data['is_ldap_user']) if user is None: messages.add_message( request, messages.ERROR, auth_messages.get("user_invalid")) else: request.session.set_expiry(SESSION_EXPIRY_AGE) auth = AuthSession(request.session) user = user.get('user') if user.get('permission') is None: messages.add_message( request, messages.ERROR, auth_messages.get("nogroup_error")) return render_to_response(templates.LOGIN, {'form': form, 'form_pass': form_pass, 'modal': modal_auto_open}, context_instance=RequestContext(request)) auth.login(User(user.get('id'), user.get('user'), user.get('nome'), user.get( 'email'), user.get('pwd'), user.get('permission'), user.get('ativo'), user.get('user_ldap'))) if form.cleaned_data['redirect'] != "": return HttpResponseRedirect(form.cleaned_data['redirect']) return HttpResponseRedirect(URL_HOME) except InvalidParameterError, e: logger.error(e) messages.add_message( request, messages.ERROR, auth_messages.get("user_invalid")) except NetworkAPIClientError, e: logger.error(e) messages.add_message(request, messages.ERROR, e) except LDAPNotFoundError, e: logger.error(e) messages.add_message( request, messages.ERROR, auth_messages.get("user_ldap_not_found"))
def setUp(self): self.networkapi_url = os.getenv('NETWORKAPI_URL', 'http://10.0.0.2:8000/') self.networkapi_user = os.getenv('NETWORKAPI_USER', 'networkapi') self.networkapi_pwd = os.getenv('NETWORKAPI_PWD', 'networkapi') self.client_api = ClientFactory(self.networkapi_url, self.networkapi_user, self.networkapi_pwd) self.sufix = time() self.configs() self.objects = dict()
def setUp(self): self.networkapi_url = os.getenv( 'NETWORKAPI_URL', 'http://10.0.0.2:8000/') self.networkapi_user = os.getenv( 'NETWORKAPI_USER', 'networkapi') self.networkapi_pwd = os.getenv('NETWORKAPI_PWD', 'networkapi') self.client_api = ClientFactory( self.networkapi_url, self.networkapi_user, self.networkapi_pwd) self.sufix = time() self.configs() self.objects = dict()
class TestNetworkIPv4(TestCase): """ Class to test the network creation """ def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_net_ipv4 = self.client.create_api_network_ipv4() def test_list_networks(self): """ List all IPv4 networks """ networks = self.api_net_ipv4.list() assert_is_instance(networks, list) assert_greater(len(networks), 1) def test_create_new_ipv4_network_dinamically_by_prefix(self): """ Create a new IPv4 network """ data = { 'vlan': 3, 'network_type': 2, 'environmentvip': None, 'prefix': 28, } network_id = self.api_net_ipv4.create([data])[0]['id'] network = self.api_net_ipv4.get([network_id])['networks'][0] assert_equal(network['prefix'], 28) assert_equal(network['broadcast'], '10.0.1.15') self.api_net_ipv4.delete([network_id]) def test_create_new_ipv4_network_by_octets(self): """ Creates new IPv4 network by the octets """ data = { 'vlan': 3, 'network_type': 2, 'environmentvip': None, 'prefix': 30, 'oct1': 10, 'oct2': 0, 'oct3': 1, 'oct4': 0, } network_id = self.api_net_ipv4.create([data])[0]['id'] network = self.api_net_ipv4.get([network_id])['networks'][0] assert_equal(network['prefix'], 30) assert_equal(network['broadcast'], '10.0.1.3') assert_equal(network['mask_oct4'], 252) self.api_net_ipv4.delete([network_id]) def test_create_a_network_with_only_network_type(self): """ Create new IPv4 network using only the network_type """ data = { 'vlan': 3, 'network_type': 2, } network_id = self.api_net_ipv4.create([data])[0]['id'] network = self.api_net_ipv4.get([network_id])['networks'][0] assert_equal(network['vlan'], data['vlan']) assert_equal(network['network_type'], data['network_type']) assert_equal(network['id'], network_id) self.api_net_ipv4.delete([network_id]) def test_delete_network(self): """ Deletes a ipv4 newtork """ data = { 'vlan': 3, 'network_type': 2, } network_id = self.api_net_ipv4.create([data])[0]['id'] response = self.api_net_ipv4.delete([network_id]) assert_is_instance(response, list) assert_equal(len(response), 0) def test_delete_a_non_existent_ipv4_network(self): """ Tries to delete a non existent ipv4 network """ with assert_raises(NetworkAPIClientError): response = self.api_net_ipv4.delete([5555]) def test_delete_an_active_network(self): """ Tries to delete an active ipv4 network """ active_network_id = 7 with assert_raises(NetworkAPIClientError): self.api_net_ipv4.delete([active_network_id]) def test_update_network(self): """ Updating ipv4 network data """ data = { 'vlan': 3, 'network_type': 2, } network_id = self.api_net_ipv4.create([data])[0]['id'] data['network_type'] = 6 data.update({'id': network_id}) self.api_net_ipv4.update([data]) network = self.api_net_ipv4.get([network_id])['networks'][0] assert_equal(network['network_type'], data['network_type']) self.api_net_ipv4.delete([network_id]) def test_update_a_field_not_editable_on_a_network(self): """ Tries to update a field not editable on a network """ data = { 'id': 7, 'vlan': 3, 'network_type': 2, 'active': False, } self.api_net_ipv4.update([data]) network = self.api_net_ipv4.get([data['id']])['networks'][0] assert_true(network['active']) def test_create_network_on_an_environment_that_have_a_router(self): """ Creates a network on an environment that have a router """ data = { 'vlan': 10, 'network_type': 2, } expected_equipament_id = 12 # This equipament is a router network_id = self.api_net_ipv4.create([data])[0]['id'] api_ip = self.client.create_api_ipv4() network = api_ip.search(search={'networkipv4': network_id}, include=['equipments']) equipments_ids = [] for ip in network['ips']: for equipment in ip['equipments']: equipments_ids.append(equipment['id']) assert_in(expected_equipament_id, equipments_ids) self.api_net_ipv4.delete([network_id]) def test_create_network_on_an_environment_that_have_two_routers(self): """ Creates a network on an environment that have two routers """ data = { 'vlan': 3, 'network_type': 2, } expected_equipaments_id = (26, 27) # These equipaments are routers network_id = self.api_net_ipv4.create([data])[0]['id'] api_ip = self.client.create_api_ipv4() network = api_ip.search(search={'networkipv4': network_id}, include=['equipments']) equipments_ids = [] for ip in network['ips']: for equipment in ip['equipments']: equipments_ids.append(equipment['id']) assert_in(expected_equipaments_id[0], equipments_ids) assert_in(expected_equipaments_id[1], equipments_ids) self.api_net_ipv4.delete([network_id])
class TestNetworkIPv4(TestCase): """ Class to test the network creation """ def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_net_ipv4 = self.client.create_api_network_ipv4() def test_list_networks(self): """ List all IPv4 networks """ networks = self.api_net_ipv4.list() assert_is_instance(networks, list) assert_greater(len(networks), 1) def test_create_new_ipv4_network_dinamically_by_prefix(self): """ Create a new IPv4 network """ data = { 'vlan': 3, 'network_type': 2, 'environmentvip': None, 'prefix': 28, } network_id = self.api_net_ipv4.create([data])[0]['id'] network = self.api_net_ipv4.get([network_id])['networks'][0] assert_equal(network['prefix'], 28) assert_equal(network['broadcast'], '10.0.1.15') self.api_net_ipv4.delete([network_id]) def test_create_new_ipv4_network_by_octets(self): """ Creates new IPv4 network by the octets """ data = { 'vlan': 3, 'network_type': 2, 'environmentvip': None, 'prefix': 30, 'oct1': 10, 'oct2': 0, 'oct3': 1, 'oct4': 0, } network_id = self.api_net_ipv4.create([data])[0]['id'] network = self.api_net_ipv4.get([network_id])['networks'][0] assert_equal(network['prefix'], 30) assert_equal(network['broadcast'], '10.0.1.3') assert_equal(network['mask_oct4'], 252) self.api_net_ipv4.delete([network_id]) def test_create_a_network_with_only_network_type(self): """ Create new IPv4 network using only the network_type """ data = { 'vlan': 3, 'network_type': 2, } network_id = self.api_net_ipv4.create([data])[0]['id'] network = self.api_net_ipv4.get([network_id])['networks'][0] assert_equal(network['vlan'], data['vlan']) assert_equal(network['network_type'], data['network_type']) assert_equal(network['id'], network_id) self.api_net_ipv4.delete([network_id]) def test_delete_network(self): """ Deletes a ipv4 newtork """ data = { 'vlan': 3, 'network_type': 2, } network_id = self.api_net_ipv4.create([data])[0]['id'] response = self.api_net_ipv4.delete([network_id]) assert_is_instance(response, list) assert_equal(len(response), 0) def test_delete_a_non_existent_ipv4_network(self): """ Tries to delete a non existent ipv4 network """ with assert_raises(NetworkAPIClientError): response = self.api_net_ipv4.delete([5555]) def test_delete_an_active_network(self): """ Tries to delete an active ipv4 network """ active_network_id = 7 with assert_raises(NetworkAPIClientError): self.api_net_ipv4.delete([active_network_id]) def test_update_network(self): """ Updating ipv4 network data """ data = { 'vlan': 3, 'network_type': 2, } network_id = self.api_net_ipv4.create([data])[0]['id'] data['network_type'] = 6 data.update({'id': network_id}) self.api_net_ipv4.update([data]) network = self.api_net_ipv4.get([network_id])['networks'][0] assert_equal(network['network_type'], data['network_type']) self.api_net_ipv4.delete([network_id]) def test_update_a_field_not_editable_on_a_network(self): """ Tries to update a field not editable on a network """ data = { 'id': 7, 'vlan': 3, 'network_type': 2, 'active': False, } self.api_net_ipv4.update([data]) network = self.api_net_ipv4.get([data['id']])['networks'][0] assert_true(network['active']) def test_create_network_on_an_environment_that_have_a_router(self): """ Creates a network on an environment that have a router """ data = { 'vlan': 10, 'network_type': 2, } expected_equipament_id = 12 # This equipament is a router network_id = self.api_net_ipv4.create([data])[0]['id'] api_ip = self.client.create_api_ipv4() network = api_ip.search( search={'networkipv4': network_id}, include=['equipments'] ) equipments_ids = [] for ip in network['ips']: for equipment in ip['equipments']: equipments_ids.append(equipment['id']) assert_in(expected_equipament_id, equipments_ids) self.api_net_ipv4.delete([network_id]) def test_create_network_on_an_environment_that_have_two_routers(self): """ Creates a network on an environment that have two routers """ data = { 'vlan': 3, 'network_type': 2, } expected_equipaments_id = (26, 27) # These equipaments are routers network_id = self.api_net_ipv4.create([data])[0]['id'] api_ip = self.client.create_api_ipv4() network = api_ip.search( search={'networkipv4': network_id}, include=['equipments'] ) equipments_ids = [] for ip in network['ips']: for equipment in ip['equipments']: equipments_ids.append(equipment['id']) assert_in(expected_equipaments_id[0], equipments_ids) assert_in(expected_equipaments_id[1], equipments_ids) self.api_net_ipv4.delete([network_id])
class ApiNetworksTestCase(TestCase): def setUp(self): self.networkapi_url = os.getenv('NETWORKAPI_URL', 'http://10.0.0.2:8000/') self.networkapi_user = os.getenv('NETWORKAPI_USER', 'networkapi') self.networkapi_pwd = os.getenv('NETWORKAPI_PWD', 'networkapi') self.client_api = ClientFactory(self.networkapi_url, self.networkapi_user, self.networkapi_pwd) self.sufix = time() self.configs() self.objects = dict() def tearDown(self): try: # Removes Vlans of Racks self.remove_all_vlans([self.objects['id_envrk_A']]) self.remove_all_vlans([self.objects['id_envrk_B']]) self.remove_all_vlans([self.objects['id_envrk_C']]) self.remove_all_vlans([self.objects['id_envrk_D']]) except: pass try: # Removes environment of load balancing self.client_api.create_api_environment()\ .delete(self.objects['id_envlb']) # Removes environment of racks self.client_api.create_api_environment()\ .delete(self.objects['id_envrk_A']) self.client_api.create_api_environment()\ .delete(self.objects['id_envrk_B']) self.client_api.create_api_environment()\ .delete(self.objects['id_envrk_C']) self.client_api.create_api_environment()\ .delete(self.objects['id_envrk_D']) except: pass # Removes vrfs try: self.client_api.create_api_vrf().delete(self.objects['id_vrf']) except: pass # Removes Environment DC for id_envdc in self.objects['id_envdc']: try: self.client_api.create_divisao_dc().remover(id_envdc) except: pass # Removes Environment Logic for id_envlog in self.objects['id_envlog']: try: self.client_api.create_ambiente_logico().remover(id_envlog) except: pass # Removes Environment layer 3 for load balancing for id_envl3 in self.objects['id_envl3']: try: self.client_api.create_grupo_l3().remover(id_envl3) except: pass # Removes eqpts try: self.client_api.create_api_create().delete(self.objects['id_eqpt']) except: pass def test_create_networkv4_by_zero(self): """ Test of integration for create environment, vlan, eqpt networks v4. ################## Starting test: - environment A: - eqpt 1, 2, 3 - vrf 1 - starting vlans 1,2,3 - environment B: - eqpt 2, 4, 5 - vrf 1 - starting vlans 4, 5, 6, 7, 8, 9 - environment C: - EQpt 5, 6 - vrf 2 - startinG vlans 10, 11 - environment D: - eqpt 7 - vrf 1 - starting vlans 1 ################## ################## Inserting new vlans without numbers: - environment A: Expected 10 - environment B: Expected 12 - environment C: Expected 1 - environment C: Expected 2 - environment C: Expected 3 - environment C: Expected 13 - environment B: Expected 14 - environment B: Expected 15 - environment B: Expected 16 - environment A: Expected 11 - environment A: Expected 13 - environment A: Expected 17 - environment A: Expected 18 - environment B: Expected 19 - environment C: Expected 17 - environment D: Expected 1 ################## ################## Starting networks: environment A: Nothing environment B: 10.0.1.0/24 10.0.2.0/25 10.0.3.0/24 environment C: Nothing environment D: Nothing ################## ################## Inserting networks without octs: - environment B: Expected 10.0.0.0/24 - environment C: Expected 10.0.0.0/25 - environment C using prefix 24: Expected 10.0.1.0/24 - environment A: Expected 10.0.2.128/25 - environment A: Expected 10.0.4.0/25 - environment B: Expected 10.0.5.0/24 - environment A: Expected 10.0.4.128/25 - environment D: Expected 10.0.0.0/24 ################## """ # Creates VRF 1 id_vrf_a = self.create_vrf('BeTeste-1') self.objects['id_vrf'] = [id_vrf_a] # Creates VRF 2 id_vrf_b = self.create_vrf('BeTeste-2') self.objects['id_vrf'].append(id_vrf_b) # Creates Environment DC and Logic id_envdc = self.create_envdc('BE-TESTE') id_envlog = self.create_envlog('TESTE') self.objects['id_envdc'] = [id_envdc] self.objects['id_envlog'] = [id_envlog] # Creates environment layer 3 for load balancing id_envl3 = self.create_envl3('BALANCEAMENTO-POOL') self.objects['id_envl3'] = [id_envl3] # Creates environment of load balancing id_env = self.create_env(id_envl3, id_envlog, id_envdc, id_vrf_a, self.configs['env_lb']) self.objects['id_envlb'] = [id_env] env_list = {'A': id_vrf_a, 'B': id_vrf_a, 'C': id_vrf_b, 'D': id_vrf_a} # Creates environments of racks for i in env_list: # Creates environment layer 3 for racks id_envl3 = self.create_envl3('RACK-%s' % i) self.objects['id_envl3'].append(id_envl3) id_env = self.create_env(id_envl3, id_envlog, id_envdc, env_list[i], self.configs[i]) self.objects['id_envrk_' + i] = id_env # Creates equipments with relationship environments self.create_equipments() # Creates vlans with numbers self.create_vlans_with_number_envs() # Creates vlans with auto numbers self.create_vlans_without_number() # Creates networks v4 with octs self.create_netv4_with_octs() # Creates networks with auto octs and prefix self.create_netv4_without_octs() def test_create_networkv6_by_zero(self): """ Test of integration for create environment, vlan, eqpt networks v6. ################## Starting test: - environment A: - eqpt 1, 2, 3 - vrf 1 - starting vlans 1,2,3 - environment B: - eqpt 2, 4, 5 - vrf 1 - starting vLANS 4, 5, 6, 7, 8, 9 - environment C: - EQpt 5, 6 - vrf 2 - startinG VLANS 10, 11 - environment D: - eqpt 7 - vrf 1 - starting vlans 1 ################## ################## Inserting new vlans: - environment A: 10 - environment B: 12 - environment C: 1 - environment C: 2 - environment C: 3 - environment C: 13 - environment B: 14 - environment B: 15 - environment B: 16 - environment A: 11 - environment A: 13 - environment A: 17 - environment A: 18 - environment B: 19 - environment C: 17 - environment D: 1 ################## ################## Starting networks: environment A: Nothing environment B: fdbe:bebe:bebe:1201:0000:0000:0000:0000/64 fdbe:bebe:bebe:1202:0000:0000:0000:0000/65 fdbe:bebe:bebe:1203:0000:0000:0000:0000/64 environment C: Nothing environment D: Nothing ################## ################## Inserting networks: - environment B:fdbe:bebe:bebe:1200:0000:0000:0000:0000/64 - environment C:fdbe:bebe:bebe:1200:0000:0000:0000:0000/65 - environment C using prefix 24: fdbe:bebe:bebe:1201:0000:0000:0000:0000/64 - environment A:fdbe:bebe:bebe:1202:8000:0000:0000:0000/65 - environment A:fdbe:bebe:bebe:1204:0000:0000:0000:0000/65 - environment B:fdbe:bebe:bebe:1205:0000:0000:0000:0000/64 - environment A:fdbe:bebe:bebe:1204:8000:0000:0000:0000/65 - environment D:fdbe:bebe:bebe:1200:0000:0000:0000:0000/64 ################## """ # Creates VRF 1 id_vrf_a = self.create_vrf('BeTeste-1') self.objects['id_vrf'] = [id_vrf_a] # Creates VRF 2 id_vrf_b = self.create_vrf('BeTeste-2') self.objects['id_vrf'].append(id_vrf_b) # Creates Environment DC and Logic id_envdc = self.create_envdc('BE-TESTE') id_envlog = self.create_envlog('TESTE') self.objects['id_envdc'] = [id_envdc] self.objects['id_envlog'] = [id_envlog] # Creates environment layer 3 for load balancing id_envl3 = self.create_envl3('BALANCEAMENTO-POOL') self.objects['id_envl3'] = [id_envl3] # Creates environment of load balancing id_env = self.create_env(id_envl3, id_envlog, id_envdc, id_vrf_a, self.configs['env_lb']) self.objects['id_envlb'] = [id_env] env_list = {'A': id_vrf_a, 'B': id_vrf_a, 'C': id_vrf_b, 'D': id_vrf_a} # Creates environments of racks for i in env_list: # Creates environment layer 3 for racks id_envl3 = self.create_envl3('RACK-%s' % i) self.objects['id_envl3'].append(id_envl3) id_env = self.create_env(id_envl3, id_envlog, id_envdc, env_list[i], self.configs[i]) self.objects['id_envrk_' + i] = id_env # Creates equipments with relationship environments self.create_equipments() # Creates vlans with numbers self.create_vlans_with_number_envs() # Creates vlans with auto numbers self.create_vlans_without_number() # Creates networks with octs self.create_netv6_with_octs() # Creates networks with auto octs and prefix self.create_netv6_without_octs() def configs(self): self.configs = { 'env_lb': [{ 'subnet': 'febe:bebe:bebe:8200:0:0:0:0/57', 'new_prefix': '64', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.10.0.0/16', 'new_prefix': '24', 'type': 'v4', 'network_type': 8 }], 'A': [{ 'subnet': 'fdbe:bebe:bebe:1200:0000:0000:0000:0000/57', 'new_prefix': '65', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.0.0.0/16', 'new_prefix': '25', 'type': 'v4', 'network_type': 8 }], 'B': [{ 'subnet': 'fdbe:bebe:bebe:1200:0000:0000:0000:0000/57', 'new_prefix': '64', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.0.0.0/16', 'new_prefix': '24', 'type': 'v4', 'network_type': 8 }], 'C': [{ 'subnet': 'fdbe:bebe:bebe:1200:0000:0000:0000:0000/57', 'new_prefix': '65', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.0.0.0/16', 'new_prefix': '25', 'type': 'v4', 'network_type': 8 }], 'D': [{ 'subnet': 'fdbe:bebe:bebe:1200:0000:0000:0000:0000/57', 'new_prefix': '64', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.0.0.0/16', 'new_prefix': '24', 'type': 'v4', 'network_type': 8 }] } def create_envdc(self, name): """Creates Environment DC""" id_envdc = self.client_api.create_divisao_dc()\ .inserir('%s-%s' % (name, self.sufix))['division_dc']['id'] return id_envdc def create_envlog(self, name): """Creates Environment Logic""" id_envlog = self.client_api.create_ambiente_logico()\ .inserir('%s-%s' % (name, self.sufix))['logical_environment']['id'] return id_envlog def create_envl3(self, name): """Creates environment layer 3 for load balancing.""" id_envl3 = self.client_api.create_grupo_l3()\ .inserir('%s-%s' % (name, self.sufix))['group_l3']['id'] return id_envl3 def create_vrf(self, name): """Creates VRF.""" vrf_dict = [{ 'internal_name': '%s-%s' % (name, self.sufix), 'vrf': '%s-%s' % (name, self.sufix) }] id_vrf = self.client_api.create_api_vrf()\ .create(vrf_dict)[0]['id'] return id_vrf def create_env(self, id_envl3, id_envlog, id_envdc, id_vrf, configs): """Creates environment.""" env_dict = [{ 'grupo_l3': int(id_envl3), 'ambiente_logico': int(id_envlog), 'divisao_dc': int(id_envdc), 'filter': 1, 'default_vrf': id_vrf, 'min_num_vlan_1': 1, 'max_num_vlan_1': 500, 'min_num_vlan_2': 1000, 'max_num_vlan_2': 1500, 'configs': configs }] id_env = self.client_api.create_api_environment()\ .create(env_dict)[0]['id'] return id_env def create_equipments(self): """Creates equipments.""" eqpt_dict = [{ 'name': 'TESTE-EQUIP-1%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_A'] }] }, { 'name': 'TESTE-EQUIP-2%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_A'] }] }, { 'name': 'TESTE-EQUIP-3%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_A'] }, { 'is_router': False, 'environment': self.objects['id_envrk_B'] }] }, { 'name': 'TESTE-EQUIP-4%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_B'] }] }, { 'name': 'TESTE-EQUIP-5%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_B'] }, { 'is_router': False, 'environment': self.objects['id_envrk_C'] }] }, { 'name': 'TESTE-EQUIP-6%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_C'] }] }, { 'name': 'TESTE-EQUIP-7%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_D'] }] }] ids = self.client_api.create_api_equipment().create(eqpt_dict) self.objects['id_eqpt'] = ids def create_vlans_without_number(self): """Creates vlans without number.""" id_env_a = self.objects['id_envrk_A'] id_env_b = self.objects['id_envrk_B'] id_env_c = self.objects['id_envrk_C'] id_env_d = self.objects['id_envrk_D'] list_envs_alocate_vlans = [ id_env_a, id_env_b, id_env_c, id_env_c, id_env_c, id_env_c, id_env_b, id_env_b, id_env_b, id_env_a, id_env_a, id_env_a, id_env_a, id_env_b, id_env_c, id_env_d ] list_expected_num_vlans = [ 10, 12, 1, 2, 3, 13, 14, 15, 16, 11, 13, 17, 18, 19, 17, 1 ] vlans = [] for i, id_env in enumerate(list_envs_alocate_vlans): vlan = [{ 'name': 'Vlan auto %s - %s' % (i, self.sufix), 'environment': id_env }] id_vlan = [self.client_api.create_api_vlan().create(vlan)[0]['id']] vlan_obj = self.client_api.create_api_vlan().get( id_vlan)['vlans'][0] vlans.append(vlan_obj) self.verify_num_vlan(vlans, list_expected_num_vlans) def create_vlans_with_number(self, nums_vlan, id_env): """Creates vlans with number.""" vlans = [] for num_vlan in nums_vlan: vlan = [{ 'name': 'Vlan %s' % (num_vlan), 'environment': id_env, 'num_vlan': num_vlan }] id_vlan = [self.client_api.create_api_vlan().create(vlan)[0]['id']] vlan_obj = self.client_api.create_api_vlan().get( id_vlan)['vlans'][0] vlans.append(vlan_obj) return vlans def create_vlans_with_number_envs(self): """Creates vlans with number for environments A, B and C.""" id_env_a = self.objects['id_envrk_A'] id_env_b = self.objects['id_envrk_B'] id_env_c = self.objects['id_envrk_C'] # Environment A # [1, 2, 3] nums_vlan = range(1, 4) # Creates Vlans id_vlans = self.create_vlans_with_number(nums_vlan, id_env_a) ids = [id_vlan['id'] for id_vlan in id_vlans] # Get Vlans vlans = self.client_api.create_api_vlan().get(ids)['vlans'] # Verify num vlans was created self.verify_num_vlan(vlans, nums_vlan) # Environment B # [4, 5, 6, 7, 8, 9] nums_vlan = range(4, 10) # Creates Vlans id_vlans = self.create_vlans_with_number(nums_vlan, id_env_b) ids = [id_vlan['id'] for id_vlan in id_vlans] # Get Vlans vlans = self.client_api.create_api_vlan().get(ids)['vlans'] # Verify num vlans was created self.verify_num_vlan(vlans, nums_vlan) # Environment C # [10, 11] nums_vlan = range(10, 12) # Creates Vlans id_vlans = self.create_vlans_with_number(nums_vlan, id_env_c) ids = [id_vlan['id'] for id_vlan in id_vlans] # Get Vlans vlans = self.client_api.create_api_vlan().get(ids)['vlans'] # Verify num vlans was created self.verify_num_vlan(vlans, nums_vlan) def verify_num_vlan(self, objs, nums_vlan): for obj, num_vlan in izip(objs, nums_vlan): self.assertEqual( num_vlan, obj.get('num_vlan'), 'Num vlan should be %s was %s' % (num_vlan, obj.get('num_vlan'))) def search_all_vlans(self, ids_env): search_vlan = { 'start_record': 0, 'end_record': 100, 'asorting_cols': [], 'searchable_columns': [], 'extends_search': [{ 'ambiente': id_env } for id_env in ids_env] } vlans = self.client_api.create_api_vlan()\ .search(search=search_vlan, fields=['id'])['vlans'] ids_vlans = [id_vlan['id'] for id_vlan in vlans] return ids_vlans def remove_all_vlans(self, ids_env): ids_vlans = self.search_all_vlans(ids_env) if ids_vlans: search_net = { 'start_record': 0, 'end_record': 100, 'asorting_cols': [], 'searchable_columns': [], 'extends_search': [{ 'vlan': id_vlan } for id_vlan in ids_vlans] } networks = self.client_api.create_api_network_ipv4()\ .search(search=search_net, fields=['id'])['networks'] ids_networks = [id['id'] for id in networks] if ids_networks: self.client_api.create_api_network_ipv4().delete(ids_networks) networks = self.client_api.create_api_network_ipv6()\ .search(search=search_net, fields=['id'])['networks'] ids_networks = [id['id'] for id in networks] if ids_networks: self.client_api.create_api_network_ipv6().delete(ids_networks) self.client_api.create_api_vlan().delete(ids_vlans) def create_netv4_with_octs(self): """Creates networks v4 using first vlan.""" networks = [{ 'oct1': 10, 'oct2': 0, 'oct3': 1, 'oct4': 0, 'prefix': 24, 'env': self.objects['id_envrk_B'] }, { 'oct1': 10, 'oct2': 0, 'oct3': 2, 'oct4': 0, 'prefix': 25, 'env': self.objects['id_envrk_B'] }, { 'oct1': 10, 'oct2': 0, 'oct3': 3, 'oct4': 0, 'prefix': 24, 'env': self.objects['id_envrk_B'] }] fields = ['oct1', 'oct2', 'oct3', 'oct4', 'prefix', 'vlan'] for network_send in networks: # Get all vlans of environment ids_vlans = self.search_all_vlans([network_send.get('env')]) del network_send['env'] # Creates networks v4 network_send['vlan'] = ids_vlans[0] network = [{ 'oct1': network_send.get('oct1'), 'oct2': network_send.get('oct2'), 'oct3': network_send.get('oct3'), 'oct4': network_send.get('oct4'), 'prefix': network_send.get('prefix'), 'vlan': network_send.get('vlan'), 'network_type': 6, 'environmentvip': None }] id_network = self.client_api.create_api_network_ipv4()\ .create(network)[0]['id'] # Get object created network_rec = self.client_api.create_api_network_ipv4()\ .get([id_network], fields=fields)['networks'][0] # Verify if object is right self.assertDictEqual( network_send, network_rec, 'Network should be %s and was %s' % (network_send, network_rec)) def create_netv4_without_octs(self): networks = [{ 'prefix': None, 'env': self.objects['id_envrk_B'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_C'], 'network_type': 6, 'environmentvip': None }, { 'prefix': 24, 'env': self.objects['id_envrk_C'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_B'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_D'], 'network_type': 6, 'environmentvip': None }] expected_networks = [{ 'oct1': 10, 'oct2': 0, 'oct3': 0, 'oct4': 0, 'prefix': 24, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 0, }, { 'oct1': 10, 'oct2': 0, 'oct3': 0, 'oct4': 0, 'prefix': 25, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 128, }, { 'oct1': 10, 'oct2': 0, 'oct3': 1, 'oct4': 0, 'prefix': 24, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 0, }, { 'oct1': 10, 'oct2': 0, 'oct3': 2, 'oct4': 128, 'prefix': 25, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 128 }, { 'oct1': 10, 'oct2': 0, 'oct3': 4, 'oct4': 0, 'prefix': 25, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 128 }, { 'oct1': 10, 'oct2': 0, 'oct3': 5, 'oct4': 0, 'prefix': 24, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 0 }, { 'oct1': 10, 'oct2': 0, 'oct3': 4, 'oct4': 128, 'prefix': 25, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 128 }, { 'oct1': 10, 'oct2': 0, 'oct3': 0, 'oct4': 0, 'prefix': 24, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 0 }] fields = [ 'oct1', 'oct2', 'oct3', 'oct4', 'prefix', 'mask_oct1', 'mask_oct2', 'mask_oct3', 'mask_oct4', ] for network_send, expected_network in izip(networks, expected_networks): # Get all vlans of environment ids_vlans = self.search_all_vlans([network_send.get('env')]) # Creates networks v4 network_send['vlan'] = ids_vlans[0] id_network = self.client_api.create_api_network_ipv4()\ .create([network_send])[0]['id'] network_rec = self.client_api.create_api_network_ipv4()\ .get([id_network], fields=fields)['networks'][0] self.assertDictEqual( expected_network, network_rec, 'Network should be %s and was %s' % (expected_network, network_rec)) def create_netv6_with_octs(self): """Creates networks v6 using first vlan.""" networks = [{ 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1201', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000', 'env': self.objects['id_envrk_B'] }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1202', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000', 'env': self.objects['id_envrk_B'] }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1203', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000', 'env': self.objects['id_envrk_B'] }] fields = [ 'block1', 'block2', 'block3', 'block4', 'block5', 'block6', 'block7', 'block8', 'prefix', 'mask1', 'mask2', 'mask3', 'mask4', 'mask5', 'mask6', 'mask7', 'mask8', 'vlan' ] for network_send in networks: # Get all vlans of environment ids_vlans = self.search_all_vlans([network_send.get('env')]) del network_send['env'] # Creates networks v4 network_send['vlan'] = ids_vlans[0] network = [{ 'block1': network_send.get('block1'), 'block2': network_send.get('block2'), 'block3': network_send.get('block3'), 'block4': network_send.get('block4'), 'block5': network_send.get('block5'), 'block6': network_send.get('block6'), 'block7': network_send.get('block7'), 'block8': network_send.get('block8'), 'prefix': network_send.get('prefix'), 'vlan': network_send.get('vlan'), 'network_type': 6, 'environmentvip': None }] id_network = self.client_api.create_api_network_ipv6()\ .create(network)[0]['id'] # Get object created network_rec = self.client_api.create_api_network_ipv6()\ .get([id_network], fields=fields)['networks'][0] # Verify if object is right self.assertDictEqual( network_send, network_rec, 'Network should be %s and was %s' % (network_send, network_rec)) def create_netv6_without_octs(self): networks = [{ 'prefix': None, 'env': self.objects['id_envrk_B'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_C'], 'network_type': 6, 'environmentvip': None }, { 'prefix': 64, 'env': self.objects['id_envrk_C'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_B'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_D'], 'network_type': 6, 'environmentvip': None }] expected_networks = [{ 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1200', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1200', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1201', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1202', 'block5': '8000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1204', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1205', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1204', 'block5': '8000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1200', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }] fields = [ 'block1', 'block2', 'block3', 'block4', 'block5', 'block6', 'block7', 'block8', 'prefix', 'mask1', 'mask2', 'mask3', 'mask4', 'mask5', 'mask6', 'mask7', 'mask8' ] for network_send, expected_network in izip(networks, expected_networks): # Get all vlans of environment ids_vlans = self.search_all_vlans([network_send.get('env')]) # Creates networks v4 network_send['vlan'] = ids_vlans[0] id_network = self.client_api.create_api_network_ipv6()\ .create([network_send])[0]['id'] network_rec = self.client_api.create_api_network_ipv6()\ .get([id_network], fields=fields)['networks'][0] self.assertDictEqual( expected_network, network_rec, 'Network should be %s and was %s' % (expected_network, network_rec))
def __init__(self): self.client = ClientFactory( NETWORKAPI_ENDPOINT, NETWORKAPI_USER, NETWORKAPI_PASSWORD )
class TestApiVrf(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_vrf = self.client.create_api_vrf() self.api_environment = self.client.create_api_environment() def tearDown(self): pass # post tests def test_create_vrf(self): """ Tries to create a new vrf """ vrf_data = [{'internal_name': 'Vrf-1', 'vrf': 'Vrf-1'}] vrf_id = self.api_vrf.create(vrf_data)[0]['id'] vrf = self.api_vrf.get([vrf_id]) assert_equal(vrf['vrfs'][0]['id'], vrf_id) self.api_vrf.delete([vrf_id]) def test_create_many_vrfs(self): """ Tries to create many vrfs """ vrfs_data = [{ 'internal_name': 'Vrf-1', 'vrf': 'Vrf-1' }, { 'internal_name': 'Vrf-2', 'vrf': 'Vrf-2' }] vrfs_ids = [e['id'] for e in self.api_vrf.create(vrfs_data)] vrfs = self.api_vrf.get(vrfs_ids) assert_equal(len(vrfs['vrfs']), 2) for vrf in vrfs['vrfs']: assert_in(vrf['id'], vrfs_ids) self.api_vrf.delete(vrfs_ids) # delete tests def test_delete_vrf(self): """ Tests if we can delete an vrf """ vrf_data = {'internal_name': 'Vrf-1', 'vrf': 'Vrf-1'} vrf_id = self.api_vrf.create([vrf_data])[0]['id'] assert_is_instance(self.api_vrf.get([vrf_id]), dict) self.api_vrf.delete([vrf_id]) with assert_raises(NetworkAPIClientError): self.api_vrf.get([vrf_id]) def test_delete_a_non_existent_vrf(self): """ Tries to delete a non existent vrf """ with assert_raises(NetworkAPIClientError): self.api_vrf.delete([1111]) def test_search_an_vrf(self): """ Searches an vrf """ internal_name = 'Vrf-1' vrf = 'Vrf-1' search_data = { 'extends_search': [{ 'internal_name': internal_name, 'vrf': vrf, }] } vrfs = self.api_vrf.search(search=search_data) assert_equal(vrfs['total'], 1) assert_equal(vrfs['vrfs'][0]['internal_name'], internal_name) assert_equal(vrfs['vrfs'][0]['vrf'], vrf) def test_search_a_list_of_vrfs(self): """ Searches a list of vrf """ internal_names = vrf_names = ['Vrf-1', 'Vrf-2'] search_data = { 'extends_search': [{ 'internal_name': internal_names[0], 'vrf': vrf_names[0], }, { 'internal_name': internal_names[1], 'vrf': vrf_names[1], }] } vrfs = self.api_vrf.search(search=search_data) assert_equal(vrfs['total'], 2) for vrf in vrfs['vrfs']: assert_in(vrf['internal_name'], internal_names) assert_in(vrf['vrf'], vrf_names) def test_search_a_non_existent_vrf(self): """ Searches a non existent vrf """ search_data = { 'extends_search': [{ 'internal_name': 'Vrf-K-7', }] } vrfs = self.api_vrf.search(search=search_data) assert_equal(vrfs['total'], 0) def test_get_an_vrf_by_id(self): """ Get an vrf by id """ vrf = self.api_vrf.get([1]) assert_equal(vrf['vrfs'][0]['id'], 1) def test_try_to_get_a_non_existent_vrf_by_id(self): """ Tries to get a non existent vrf by id """ with assert_raises(NetworkAPIClientError): self.api_vrf.get([1000]) def test_update_an_vrf(self): """ Updates an vrf """ internal_name = vrf = 'Vrf-3' vrf_data = {'internal_name': internal_name, 'vrf': vrf} vrf_id = self.api_vrf.create([vrf_data])[0]['id'] vrf = self.api_vrf.get([vrf_id])['vrfs'][0] assert_equal(vrf['id'], vrf_id) new_internal_name = vrf['internal_name'] = 'Vrf-3-1' self.api_vrf.update([vrf]) vrf = self.api_vrf.get([vrf_id])['vrfs'][0] assert_equal(vrf['internal_name'], new_internal_name) self.api_vrf.delete([vrf_id]) def test_update_a_non_existent_vrf(self): """ Tries to update a non existent vrf """ vrf_data = {'id': 1000, 'internal_name': 'Vrf-3-1', 'vrf': 'Vrf-3-1'} with assert_raises(NetworkAPIClientError): self.api_vrf.update([vrf_data]) def test_delete_vrf_used_by_environment(self): """ Try to violate delete restriction when Vrf is used by some environment """ vrf_data = [{'internal_name': 'Vrf-1', 'vrf': 'Vrf-1'}] vrf_id = self.api_vrf.create(vrf_data)[0]['id'] env_data = [{ 'grupo_l3': 32, 'ambiente_logico': 12, 'divisao_dc': 21, 'default_vrf': vrf_id, }] env_id = self.api_environment.create(env_data)[0]['id'] with assert_raises(NetworkAPIClientError): self.api_vrf.delete([vrf_id]) self.api_environment.delete([env_id]) self.api_vrf.delete([vrf_id]) def test_try_delete_vrf_assoc_to_equipment(self): """ Try to delete vrf associated to equipment """ # TODO Need more things to continue pass def test_try_delete_vrf_assoc_to_vlan_eqpt(self): """ Try to violate delete restriction when Vrf is associated to vlan-eqpt """ # TODO Need more things to continue pass
def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_net_ipv4 = self.client.create_api_network_ipv4()
def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_vrf = self.client.create_api_vrf() self.api_environment = self.client.create_api_environment()
class TestApiVrf(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_vrf = self.client.create_api_vrf() self.api_environment = self.client.create_api_environment() def tearDown(self): pass # post tests def test_create_vrf(self): """ Tries to create a new vrf """ vrf_data = [{ 'internal_name': 'Vrf-1', 'vrf': 'Vrf-1' }] vrf_id = self.api_vrf.create(vrf_data)[0]['id'] vrf = self.api_vrf.get([vrf_id]) assert_equal(vrf['vrfs'][0]['id'], vrf_id) self.api_vrf.delete([vrf_id]) def test_create_many_vrfs(self): """ Tries to create many vrfs """ vrfs_data = [{ 'internal_name': 'Vrf-1', 'vrf': 'Vrf-1' }, { 'internal_name': 'Vrf-2', 'vrf': 'Vrf-2' }] vrfs_ids = [e['id'] for e in self.api_vrf.create(vrfs_data)] vrfs = self.api_vrf.get(vrfs_ids) assert_equal(len(vrfs['vrfs']), 2) for vrf in vrfs['vrfs']: assert_in(vrf['id'], vrfs_ids) self.api_vrf.delete(vrfs_ids) # delete tests def test_delete_vrf(self): """ Tests if we can delete an vrf """ vrf_data = { 'internal_name': 'Vrf-1', 'vrf': 'Vrf-1' } vrf_id = self.api_vrf.create([vrf_data])[0]['id'] assert_is_instance(self.api_vrf.get([vrf_id]), dict) self.api_vrf.delete([vrf_id]) with assert_raises(NetworkAPIClientError): self.api_vrf.get([vrf_id]) def test_delete_a_non_existent_vrf(self): """ Tries to delete a non existent vrf """ with assert_raises(NetworkAPIClientError): self.api_vrf.delete([1111]) def test_search_an_vrf(self): """ Searches an vrf """ internal_name = 'Vrf-1' vrf = 'Vrf-1' search_data = { 'extends_search': [{ 'internal_name': internal_name, 'vrf': vrf, }] } vrfs = self.api_vrf.search(search=search_data) assert_equal(vrfs['total'], 1) assert_equal(vrfs['vrfs'][0]['internal_name'], internal_name) assert_equal(vrfs['vrfs'][0]['vrf'], vrf) def test_search_a_list_of_vrfs(self): """ Searches a list of vrf """ internal_names = vrf_names = ['Vrf-1', 'Vrf-2'] search_data = { 'extends_search': [{ 'internal_name': internal_names[0], 'vrf': vrf_names[0], }, { 'internal_name': internal_names[1], 'vrf': vrf_names[1], }] } vrfs = self.api_vrf.search(search=search_data) assert_equal(vrfs['total'], 2) for vrf in vrfs['vrfs']: assert_in(vrf['internal_name'], internal_names) assert_in(vrf['vrf'], vrf_names) def test_search_a_non_existent_vrf(self): """ Searches a non existent vrf """ search_data = { 'extends_search': [{ 'internal_name': 'Vrf-K-7', }] } vrfs = self.api_vrf.search(search=search_data) assert_equal(vrfs['total'], 0) def test_get_an_vrf_by_id(self): """ Get an vrf by id """ vrf = self.api_vrf.get([1]) assert_equal(vrf['vrfs'][0]['id'], 1) def test_try_to_get_a_non_existent_vrf_by_id(self): """ Tries to get a non existent vrf by id """ with assert_raises(NetworkAPIClientError): self.api_vrf.get([1000]) def test_update_an_vrf(self): """ Updates an vrf """ internal_name = vrf = 'Vrf-3' vrf_data = { 'internal_name': internal_name, 'vrf': vrf } vrf_id = self.api_vrf.create([vrf_data])[0]['id'] vrf = self.api_vrf.get([vrf_id])['vrfs'][0] assert_equal(vrf['id'], vrf_id) new_internal_name = vrf['internal_name'] = 'Vrf-3-1' self.api_vrf.update([vrf]) vrf = self.api_vrf.get([vrf_id])['vrfs'][0] assert_equal(vrf['internal_name'], new_internal_name) self.api_vrf.delete([vrf_id]) def test_update_a_non_existent_vrf(self): """ Tries to update a non existent vrf """ vrf_data = { 'id': 1000, 'internal_name': 'Vrf-3-1', 'vrf': 'Vrf-3-1' } with assert_raises(NetworkAPIClientError): self.api_vrf.update([vrf_data]) def test_delete_vrf_used_by_environment(self): """ Try to violate delete restriction when Vrf is used by some environment """ vrf_data = [{ 'internal_name': 'Vrf-1', 'vrf': 'Vrf-1' }] vrf_id = self.api_vrf.create(vrf_data)[0]['id'] env_data = [{ 'grupo_l3': 32, 'ambiente_logico': 12, 'divisao_dc': 21, 'default_vrf': vrf_id, }] env_id = self.api_environment.create(env_data)[0]['id'] with assert_raises(NetworkAPIClientError): self.api_vrf.delete([vrf_id]) self.api_environment.delete([env_id]) self.api_vrf.delete([vrf_id]) def test_try_delete_vrf_assoc_to_equipment(self): """ Try to delete vrf associated to equipment """ # TODO Need more things to continue pass def test_try_delete_vrf_assoc_to_vlan_eqpt(self): """ Try to violate delete restriction when Vrf is associated to vlan-eqpt """ # TODO Need more things to continue pass
class TestApiequipment(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_environment = self.client.create_api_environment() self.api_equipment = self.client.create_api_equipment() self.non_existent_eqpt = 1000 def tearDown(self): pass # get tests def test_get_an_equipment_by_id(self): """ Get an equipment by id """ eqpt = self.api_equipment.get([1]) assert_equal(eqpt['equipments'][0]['id'], 1) def test_try_to_get_a_non_existent_equipment_by_id(self): """ Tries to get a non existent equipment by id """ with assert_raises(NetworkAPIClientError): self.api_equipment.get([self.non_existent_eqpt]) # search tests def test_search_an_equipment(self): """ Searches an equipment """ equipment_type = 2 search_data = { 'extends_search': [{ 'tipo_equipamento': equipment_type, }] } eqpts = self.api_equipment.search(search=search_data) assert_equal(eqpts['total'], 6) for eqpt in eqpts['equipments']: assert_equal(eqpt['equipment_type'], equipment_type) def test_search_a_list_of_equipments(self): """ Searches a list of equipment """ equipment_types = [2, 3] search_data = { 'extends_search': [{ 'tipo_equipamento__in': equipment_types, }] } eqpts = self.api_equipment.search(search=search_data) assert_equal(eqpts['total'], 9) for eqpt in eqpts['equipments']: assert_in(eqpt['equipment_type'], equipment_types) def test_search_a_non_existent_equipment(self): """ Searches a non existent equipment """ search_data = { 'extends_search': [{ 'tipo_equipamento': 10, }] } eqpts = self.api_equipment.search(search=search_data) assert_equal(eqpts['total'], 0) # post tests def test_create_equipment(self): """ Tries to create a new equipment """ eqpt_data = [{ 'name': 'Eqpt Teste', 'maintenance': False, 'equipment_type': 1, 'model': 1 }] eqpt_id = self.api_equipment.create(eqpt_data)[0]['id'] eqpt = self.api_equipment.get([eqpt_id]) assert_equal(eqpt['equipments'][0]['id'], eqpt_id) self.api_equipment.delete([eqpt_id]) def test_create_many_equipments(self): """ Tries to create many equipments """ eqpts_data = [{ 'name': 'Eqpt Teste-1', 'maintenance': False, 'equipment_type': 1, 'model': 1 }, { 'name': 'Eqpt Teste-2', 'maintenance': False, 'equipment_type': 1, 'model': 1 }] eqpts_ids = [e['id'] for e in self.api_equipment.create(eqpts_data)] eqpts = self.api_equipment.get(eqpts_ids) assert_equal(len(eqpts['equipments']), 2) for eqpt in eqpts['equipments']: assert_in(eqpt['id'], eqpts_ids) self.api_equipment.delete(eqpts_ids) # put tests def test_update_an_equipment(self): """ Updates an equipment """ eqpt_data = [{ 'name': 'Eqpt Test To Update', 'maintenance': False, 'equipment_type': 1, 'model': 1 }] eqpt_id = self.api_equipment.create(eqpt_data)[0]['id'] eqpt = self.api_equipment.get([eqpt_id])['equipments'][0] assert_equal(eqpt['id'], eqpt_id) new_name = eqpt['name'] = 'Eqpt New Test To Update' self.api_equipment.update([eqpt]) eqpt = self.api_equipment.get([eqpt_id])['equipments'][0] assert_equal(eqpt['name'].lower(), new_name.lower()) self.api_equipment.delete([eqpt_id]) def test_update_a_non_existent_equipment(self): """ Tries to update a non existent equipment """ eqpt_data = { 'id': self.non_existent_eqpt, 'name': 'Eqpt Teste', 'maintenance': False, 'equipment_type': 1, 'model': 1 } with assert_raises(NetworkAPIClientError): self.api_equipment.update([eqpt_data]) # delete tests def test_delete_equipment(self): """ Tests if we can delete an equipment """ eqpt_data = [{ 'name': 'Eqpt Teste', 'maintenance': False, 'equipment_type': 1, 'model': 1 }] eqpt_id = self.api_equipment.create(eqpt_data)[0]['id'] assert_is_instance(self.api_equipment.get([eqpt_id]), dict) self.api_equipment.delete([eqpt_id]) with assert_raises(NetworkAPIClientError): self.api_equipment.get([eqpt_id]) def test_delete_a_non_existent_equipment(self): """ Tries to delete a non existent equipment """ with assert_raises(NetworkAPIClientError): self.api_equipment.delete([self.non_existent_eqpt])
def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_vlan = self.client.create_api_vlan()
class TestApiVlan(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_vlan = self.client.create_api_vlan() def test_search_a_vlan(self): """ Tests the vlan search """ vlan_name = 'Vlan 31' search_data = {'extends_search': [{'nome': vlan_name}]} vlans = self.api_vlan.search(search=search_data) assert_equal(vlans['total'], 1) assert_equal(vlans['vlans'][0]['name'], vlan_name) def test_get_vlans_by_id(self): """ Gets vlans by ids """ vlans_ids = [1, 3, 5] vlans = self.api_vlan.get(vlans_ids) assert_equal(len(vlans['vlans']), 3) for vlan in vlans['vlans']: assert_in(vlan['id'], vlans_ids) def test_get_only_one_vlan_by_id(self): """ Gets only one vlan by its id """ vlan_id = 7 vlan = self.api_vlan.get([vlan_id]) assert_equal(len(vlan['vlans']), 1) assert_equal(vlan['vlans'][0]['id'], vlan_id) def test_get_a_non_existing_vlan(self): """ Attenpts to get a non existing vlan """ vlan_id = 15 with assert_raises(NetworkAPIClientError): vlan = self.api_vlan.get([vlan_id]) def test_insert_new_vlan(self): """ Tries to insert a new vlan """ vlan_data = { 'name': 'Vlan 15', 'environment': 1, } vlan_id = self.api_vlan.create([vlan_data])[0]['id'] vlan = self.api_vlan.get([vlan_id]) assert_equal(len(vlan['vlans']), 1) assert_equal(vlan['vlans'][0]['id'], vlan_id) self.api_vlan.delete([vlan_id]) def test_insert_a_duplicated_vlan(self): """ Tries to insert a duplicated vlan """ vlan_data = { 'name': 'Vlan 25', 'environment': 1, 'num_vlan': 15, } vlan_id = self.api_vlan.create([vlan_data])[0]['id'] with assert_raises(NetworkAPIClientError): self.api_vlan.create([vlan_data]) self.api_vlan.delete([vlan_id]) def test_insert_a_list_of_vlans(self): """ Tries to insert a list of vlans """ vlans_data = [{ 'name': 'Vlan 40', 'environment': 1, }, { 'name': 'Vlan 41', 'environment': 2, }, { 'name': 'Vlan 42', 'environment': 2, }] vlans_ids = [vlan['id'] for vlan in self.api_vlan.create(vlans_data)] vlans = self.api_vlan.get(vlans_ids) assert_equal(len(vlans['vlans']), 3) for vlan in vlans['vlans']: assert_in(vlan['id'], vlans_ids) self.api_vlan.delete(vlans_ids) def test_insert_a_vlan_with_wrong_data(self): """ Tries to insert a vlan with wrong data """ vlan_data = { 'name': 'Vlan 33', 'environment': 3, 'fake_data': True, } with assert_raises(NetworkAPIClientError): self.api_vlan.create([vlan_data]) def test_delete_a_single_vlan(self): """ Tries to delete a single vlan """ vlan_data = { 'name': 'Vlan 15', 'environment': 1, } vlan_id = self.api_vlan.create([vlan_data])[0]['id'] self.api_vlan.delete([vlan_id]) with assert_raises(NetworkAPIClientError): vlan = self.api_vlan.get([vlan_id]) def test_delete_a_list_of_vlans(self): """ Tries to delete a list of vlans """ vlans_data = [{ 'name': 'Vlan 40', 'environment': 1, }, { 'name': 'Vlan 41', 'environment': 2, }, { 'name': 'Vlan 42', 'environment': 2, }] vlans_ids = [vlan['id'] for vlan in self.api_vlan.create(vlans_data)] self.api_vlan.delete(vlans_ids) with assert_raises(NetworkAPIClientError): self.api_vlan.get(vlans_ids) def test_delete_a_non_existent_vlan(self): """ Tries to delete a non existent vlan """ with assert_raises(NetworkAPIClientError): self.api_vlan.delete([44]) def test_update_a_vlan(self): """ Updates a single vlan """ vlan_data = { 'name': 'Vlan 38', 'environment': 1, } vlan_id = self.api_vlan.create([vlan_data])[0]['id'] vlan = self.api_vlan.get([vlan_id])['vlans'][0] new_name = vlan['name'] = 'Vlan 40' self.api_vlan.update([vlan]) vlan = self.api_vlan.get([vlan_id])['vlans'][0] assert_equal(vlan['name'], new_name) self.api_vlan.delete([vlan_id]) def test_update_a_non_existent_vlan(self): """ Tries to update a non existent vlan """ vlan = self.api_vlan.get([1])['vlans'][0] vlan['id'] = 55 with assert_raises(NetworkAPIClientError): self.api_vlan.update([vlan])
def __init__(self): self.client = ClientFactory(NETWORKAPI_ENDPOINT, NETWORKAPI_USER, NETWORKAPI_PASSWORD)
class TestApiPool(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_environment = self.client.create_api_environment() self.api_equipment = self.client.create_api_equipment() self.api_pool = self.client.create_api_pool() self.api_environment_vip = self.client.create_api_environment_vip() self.api_vlan = self.client.create_api_vlan() self.api_network_ipv4 = self.client.create_api_network_ipv4() self.api_network_ipv6 = self.client.create_api_network_ipv6() self.api_ipv4 = self.client.create_api_ipv4() self.api_ipv6 = self.client.create_api_ipv6() self.api_pool_deploy = self.client.create_api_pool_deploy() self.ipsv4 = [{ 'id': 7, 'ip_formated': '192.168.104.2' }, { 'id': 8, 'ip_formated': '192.168.104.3' }, { 'id': 9, 'ip_formated': '192.168.104.4' }, { 'id': 10, 'ip_formated': '192.168.104.5' }, { 'id': 11, 'ip_formated': '192.168.104.6' }] self.id_env_of_pool = 10 def tearDown(self): pass # post tests - no deploy def test_create_pool_without_reals(self): """ Tries to create a pool without reals """ pool_data = self.build_pool(id_env_of_pool=self.id_env_of_pool) pool_id = self.api_pool.create([pool_data])[0]['id'] pool = self.api_pool.get([pool_id]) assert_equal(pool['server_pools'][0]['id'], pool_id) self.api_pool.delete([pool_id]) def test_create_pool_with_one_real_and_https_protocol(self): """ Tries to create a pool with one real and HTTPS protocol in healthcheck """ qt_reals = range(1) server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in qt_reals ] healthcheck_healthcheck_type = 'HTTPS' pool_data = self.build_pool( server_pool_members=server_pool_members, healthcheck__healthcheck_type=healthcheck_healthcheck_type, id_env_of_pool=self.id_env_of_pool) pool_id = self.api_pool.create([pool_data])[0]['id'] pool = self.api_pool.get([pool_id]) assert_equal(pool['server_pools'][0]['id'], pool_id) assert_equal( pool['server_pools'][0]['healthcheck']['healthcheck_type'], healthcheck_healthcheck_type) self.api_pool.delete([pool_id]) def test_create_pool_with_one_real_and_tcp_protocol(self): """ Tries to create a pool with one real and TCP protocol in healthcheck """ qt_reals = range(1) server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in qt_reals ] healthcheck_healthcheck_type = 'TCP' pool_data = self.build_pool( server_pool_members=server_pool_members, healthcheck__healthcheck_type=healthcheck_healthcheck_type, id_env_of_pool=self.id_env_of_pool) pool_id = self.api_pool.create([pool_data])[0]['id'] pool = self.api_pool.get([pool_id]) assert_equal(pool['server_pools'][0]['id'], pool_id) assert_equal( pool['server_pools'][0]['healthcheck']['healthcheck_type'], healthcheck_healthcheck_type) self.api_pool.delete([pool_id]) def test_create_pool_with_one_real_and_udp_protocol(self): """ Tries to create a pool with one real and UDP protocol in healthcheck """ qt_reals = range(1) server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in qt_reals ] healthcheck_healthcheck_type = 'UDP' pool_data = self.build_pool( server_pool_members=server_pool_members, healthcheck__healthcheck_type=healthcheck_healthcheck_type, id_env_of_pool=self.id_env_of_pool) pool_id = self.api_pool.create([pool_data])[0]['id'] pool = self.api_pool.get([pool_id]) assert_equal(pool['server_pools'][0]['id'], pool_id) assert_equal( pool['server_pools'][0]['healthcheck']['healthcheck_type'], healthcheck_healthcheck_type) self.api_pool.delete([pool_id]) def test_create_pool_with_one_real_and_http_protocol(self): """ Tries to create a pool with one real and HTTP protocol in healthcheck """ qt_reals = range(1) server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in qt_reals ] healthcheck_healthcheck_type = 'HTTP' pool_data = self.build_pool( server_pool_members=server_pool_members, healthcheck__healthcheck_type=healthcheck_healthcheck_type, id_env_of_pool=self.id_env_of_pool) pool_id = self.api_pool.create([pool_data])[0]['id'] pool = self.api_pool.get([pool_id]) assert_equal(pool['server_pools'][0]['id'], pool_id) assert_equal( pool['server_pools'][0]['healthcheck']['healthcheck_type'], healthcheck_healthcheck_type) self.api_pool.delete([pool_id]) def test_create_pool_with_three_reals_and_weight_balancing(self): """ Tries to create a pool with three reals and weight balancing """ qt_reals = range(3) weights = [1, 2, 1] server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i, weight=weights[i]) for i in qt_reals ] pool_data = self.build_pool(server_pool_members=server_pool_members, id_env_of_pool=self.id_env_of_pool) pool_id = self.api_pool.create([pool_data])[0]['id'] pool = self.api_pool.get([pool_id]) assert_equal(pool['server_pools'][0]['id'], pool_id) self.api_pool.delete([pool_id]) def test_create_pool_with_three_reals_and_least_conn_balancing(self): """ Tries to create a pool with three reals and least-conn balancing """ qt_reals = range(3) priorities = [1, 2, 1] server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i, priority=priorities[i]) for i in qt_reals ] pool_data = self.build_pool(server_pool_members=server_pool_members, id_env_of_pool=self.id_env_of_pool) pool_id = self.api_pool.create([pool_data])[0]['id'] pool = self.api_pool.get([pool_id]) assert_equal(pool['server_pools'][0]['id'], pool_id) self.api_pool.delete([pool_id]) # put tests - no deploy def test_update_pool_without_reals(self): """ Tries to update pool without reals adding two reals to it """ qt_reals = range(2) pool_data = self.build_pool(id_env_of_pool=self.id_env_of_pool) pool_id = self.api_pool.create([pool_data])[0]['id'] server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in qt_reals ] new_pool_data = self.build_pool( id=pool_id, id_env_of_pool=self.id_env_of_pool, identifier='Pool-New-Test', servicedownaction__name='drop', healthcheck__healthcheck_type='HTTPS', server_pool_members=server_pool_members) self.api_pool.update([new_pool_data]) pool = self.api_pool.get([pool_id])['server_pools'][0] assert_equal(pool['identifier'], new_pool_data['identifier']) assert_equal(pool['servicedownaction']['name'], new_pool_data['servicedownaction']['name']) assert_equal(pool['healthcheck']['healthcheck_type'], new_pool_data['healthcheck']['healthcheck_type']) assert_equal(len(pool['server_pool_members']), 2) self.api_pool.delete([pool_id]) def test_update_pool_with_reals_removing_them(self): """ Tries to update pool with reals removing them """ qt_reals = range(2) server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in qt_reals ] pool_data = self.build_pool(id_env_of_pool=self.id_env_of_pool, server_pool_members=server_pool_members) pool_id = self.api_pool.create([pool_data])[0]['id'] new_pool_data = self.build_pool(id=pool_id, id_env_of_pool=self.id_env_of_pool) self.api_pool.update([new_pool_data]) pool = self.api_pool.get([pool_id])['server_pools'][0] assert_equal(len(pool['server_pool_members']), 0) self.api_pool.delete([pool_id]) def test_update_pool_removing_half_of_reals(self): """ Tries to remove half of the reals in a server pool """ qt_reals = range(4) server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in qt_reals ] pool_data = self.build_pool(id_env_of_pool=self.id_env_of_pool, server_pool_members=server_pool_members) pool_id = self.api_pool.create([pool_data])[0]['id'] half = range(2) for i in half: server_pool_members.pop() new_pool_data = self.build_pool( id=pool_id, id_env_of_pool=self.id_env_of_pool, server_pool_members=server_pool_members) self.api_pool.update([new_pool_data]) pool = self.api_pool.get([pool_id])['server_pools'][0] assert_equal(len(pool['server_pool_members']), 2) self.api_pool.delete([pool_id]) def test_update_pool_removing_half_of_reals_and_adding_another(self): """ Tries to remove half of the reals in a server pool and at same time add a new real """ qt_reals = range(5) server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in range(4) ] pool_data = self.build_pool(id_env_of_pool=self.id_env_of_pool, server_pool_members=server_pool_members) pool_id = self.api_pool.create([pool_data])[0]['id'] half = range(2) for i in half: server_pool_members.pop() server_pool_members += [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in range(4, 5) ] new_pool_data = self.build_pool( id=pool_id, id_env_of_pool=self.id_env_of_pool, server_pool_members=server_pool_members) self.api_pool.update([new_pool_data]) pool = self.api_pool.get([pool_id])['server_pools'][0] assert_equal(len(pool['server_pool_members']), 3) self.api_pool.delete([pool_id]) # delete tests def test_delete_pool_without_reals(self): """ Tries to delete pool without reals """ pool_data = self.build_pool(id_env_of_pool=1) pool_id = self.api_pool.create([pool_data])[0]['id'] self.api_pool.delete([pool_id]) with assert_raises(NetworkAPIClientError): self.api_pool.get([pool_id]) def test_delete_pool_with_reals(self): """ Tries to delete pool with five reals """ qt_reals = range(5) server_pool_members = [ self.build_server_pool_member( ip__id=self.ipsv4[i]['id'], ip__ip_formated=self.ipsv4[i]['ip_formated'], port_real=1000 + i) for i in qt_reals ] pool_data = self.build_pool(id_env_of_pool=self.id_env_of_pool, server_pool_members=server_pool_members) pool_id = self.api_pool.create([pool_data])[0]['id'] self.api_pool.delete([pool_id]) with assert_raises(NetworkAPIClientError): self.api_pool.get([pool_id]) def create_environment_vip(self, id_env): env_vip_data = [{ 'finalidade_txt': 'Fin-Test', 'cliente_txt': 'ClientTxt-Test', 'ambiente_p44_txt': 'EnvP44Txt-Test', 'description': 'Description-Test', 'name': 'EnvVIP NetworkAPI Test', 'environments': [{ 'environment': id_env }] }] return self.api_environment_vip.create(env_vip_data)[0]['id'] def create_vlan(self, id_env): vlan_data = [{ 'name': 'Vlan of Test', 'environment': id_env, }] return self.api_vlan.create(vlan_data)[0]['id'] def create_environment_of_equipment(self): env_data = [{ 'grupo_l3': 33, 'ambiente_logico': 11, 'divisao_dc': 21, 'filter': None, 'acl_path': None, 'ipv4_template': None, 'ipv6_template': None, 'link': None, 'min_num_vlan_1': 1, 'max_num_vlan_1': 500, 'min_num_vlan_2': 501, 'max_num_vlan_2': 1000, 'vrf': None, 'default_vrf': 1, 'configs': [{ 'subnet': '192.168.104.0/22', 'new_prefix': '27', 'type': 'v4', 'network_type': 2 }, { 'subnet': 'fdbe:bebe:bebe:11c0:0000:0000:0000:0000/58', 'new_prefix': '64', 'type': 'v6', 'network_type': 2 }] }] return self.api_environment.create(env_data)[0]['id'] def create_environment_of_pool(self): env_data = [{ 'grupo_l3': 33, 'ambiente_logico': 12, 'divisao_dc': 21, 'filter': None, 'acl_path': None, 'ipv4_template': None, 'ipv6_template': None, 'link': None, 'min_num_vlan_1': 1, 'max_num_vlan_1': 500, 'min_num_vlan_2': 501, 'max_num_vlan_2': 1000, 'vrf': None, 'default_vrf': 1, 'configs': [{ 'subnet': '10.237.128.0/18', 'new_prefix': '28', 'type': 'v4', 'network_type': 2 }, { 'subnet': 'fdbe:bebe:bebe:1200:0:0:0:0/57', 'new_prefix': '64', 'type': 'v6', 'network_type': 2 }] }] return self.api_environment.create(env_data)[0]['id'] def create_real_equipment(self, name_eqpt, id_env): eqpt_data = [{ 'name': 'Server %s' % name_eqpt, 'maintenance': False, 'equipment_type': 2, 'model': 1, 'environments': [{ 'environment': id_env, 'is_router': False }] }] return self.api_equipment.create(eqpt_data)[0]['id'] def create_load_balancer_equipment(self, id_env): eqpt_data = [{ 'name': 'Load Balancer', 'maintenance': False, 'equipment_type': 5, 'model': 1, 'environments': [{ 'environment': id_env, 'is_router': False }] }] return self.api_equipment.create(eqpt_data)[0]['id'] def create_netipv4(self, id_vlan, id_env_vip): net_data = [{ 'vlan': id_vlan, 'network_type': 2, 'environmentvip': id_env_vip }] return self.api_network_ipv4.create(net_data)[0]['id'] def create_netipv6(self, id_vlan, id_env_vip): net_data = [{ 'vlan': id_vlan, 'network_type': 2, 'environmentvip': id_env_vip }] return self.api_network_ipv6.create(net_data)[0]['id'] def create_ipv4(self, id_net, id_equip): ip_data = [{ 'networkipv4': id_net, 'description': 'IP of Real', 'equipments': [{ 'id': id_equip }] }] id_ip = self.api_ipv4.create(ip_data)[0]['id'] return self.api_ipv4.get([id_ip], fields=['id', 'ip_formated'])['ips'][0] def create_ipv6(self, id_net, id_equip): ip_data = [{ 'networkipv6': id_net, 'description': 'IP of Real', 'equipments': [{ 'id': id_equip }] }] id_ip = self.api_ipv6.create(ip_data)[0]['id'] return self.api_ipv6.get([id_ip], fields=['id', 'ip_formated'])['ips'][0] def create_initial_data(self, **kwargs): weights = None priorities = None qt_reals = 0 for key in kwargs: if key == 'qt_reals': qt_reals = kwargs[key] elif key == 'weights': weights = kwargs[key] elif key == 'priorities': priorities = kwargs[key] id_env_of_eqpt = self.create_environment_of_equipment() id_env_of_pool = self.create_environment_of_pool() id_env_vip = self.create_environment_vip(id_env_of_eqpt) id_vlan_of_env_eqpt = self.create_vlan(id_env_of_eqpt) id_vlan_of_env_pool = self.create_vlan(id_env_of_pool) id_netipv4_of_vlan_env_eqpt = self.create_netipv4( id_vlan_of_env_eqpt, None) id_netipv6_of_vlan_env_eqpt = self.create_netipv6( id_vlan_of_env_eqpt, None) id_netipv4_of_vlan_env_pool = self.create_netipv4( id_vlan_of_env_pool, id_env_vip) id_netipv6_of_vlan_env_pool = self.create_netipv6( id_vlan_of_env_pool, id_env_vip) # creating three reals (servers) equipments id_reals = [ self.create_real_equipment(i, id_env_of_eqpt) for i in qt_reals ] id_load_balancer = self.create_load_balancer_equipment(id_env_of_pool) ipsv4_of_reals = [ self.create_ipv4(id_netipv4_of_vlan_env_eqpt, id_real) for id_real in id_reals ] ipsv6_of_reals = [ self.create_ipv6(id_netipv6_of_vlan_env_eqpt, id_real) for id_real in id_reals ] return { 'id_env_of_eqpt': id_env_of_eqpt, 'id_env_of_pool': id_env_of_pool, 'id_env_vip': id_env_vip, 'id_vlan_of_env_eqpt': id_vlan_of_env_eqpt, 'id_vlan_of_env_pool': id_vlan_of_env_pool, 'id_netipv4_of_vlan_env_eqpt': id_netipv4_of_vlan_env_eqpt, 'id_netipv6_of_vlan_env_eqpt': id_netipv6_of_vlan_env_eqpt, 'id_netipv4_of_vlan_env_pool': id_netipv4_of_vlan_env_pool, 'id_netipv6_of_vlan_env_pool': id_netipv6_of_vlan_env_pool, 'id_reals': id_reals, 'id_load_balancer': id_load_balancer, 'ipsv4_of_reals': ipsv4_of_reals, 'ipsv6_of_reals': ipsv6_of_reals, 'weights': weights if weights is not None else None, 'priorities': priorities if priorities is not None else None } def delete_initial_data(self, initial_data): for ipv4 in self.ipsv4: self.api_ipv4.delete([ipv4['id']]) for ipv6 in initial_data['ipsv6_of_reals']: self.api_ipv6.delete([ipv6['id']]) self.api_network_ipv4.delete( [initial_data['id_netipv4_of_vlan_env_eqpt']]) self.api_network_ipv4.delete( [initial_data['id_netipv4_of_vlan_env_pool']]) self.api_network_ipv6.delete( [initial_data['id_netipv6_of_vlan_env_eqpt']]) self.api_network_ipv6.delete( [initial_data['id_netipv6_of_vlan_env_pool']]) self.api_vlan.delete([initial_data['id_vlan_of_env_eqpt']]) self.api_vlan.delete([initial_data['id_vlan_of_env_pool']]) self.api_equipment.delete(initial_data['id_reals']) self.api_equipment.delete([initial_data['id_load_balancer']]) self.api_environment_vip.delete([initial_data['id_env_vip']]) self.api_environment.delete([initial_data['id_env_of_eqpt']]) self.api_environment.delete([initial_data['id_env_of_pool']]) def build_pool(self, **kwargs): id_env_of_pool = None healthcheck__healthcheck_type = None server_pool_members = None id = None identifier = None servicedownaction__name = None for key in kwargs: if key == 'id_env_of_pool': id_env_of_pool = kwargs[key] elif key == 'healthcheck__healthcheck_type': healthcheck__healthcheck_type = kwargs[key] elif key == 'server_pool_members': server_pool_members = kwargs[key] elif key == 'id': id = kwargs[key] elif key == 'identifier': identifier = kwargs[key] elif key == 'servicedownaction__name': servicedownaction__name = kwargs[key] return { 'id': id, 'identifier': identifier if identifier is not None else 'Pool-Test', 'default_port': 443, 'environment': id_env_of_pool, 'servicedownaction': { 'name': servicedownaction__name if servicedownaction__name is not None else 'none' }, 'lb_method': 'least-conn', 'healthcheck': { 'identifier': 'Test-Network-API-Ident', 'healthcheck_type': healthcheck__healthcheck_type if healthcheck__healthcheck_type is not None else 'HTTP', 'healthcheck_request': '', 'healthcheck_expect': '', 'destination': '*:*' }, 'default_limit': 0, 'server_pool_members': server_pool_members if server_pool_members is not None else [] } def build_server_pool_member(self, **kwargs): ip__id = None ip__ip_formated = None ipv6__id = None ipv6__ip_formated = None port_real = None weight = None priority = None id = None for key in kwargs: if key == 'ip__id': ip__id = kwargs[key] elif key == 'ip__ip_formated': ip__ip_formated = kwargs[key] elif key == 'ipv6__id': ipv6__id = kwargs[key] elif key == 'ipv6__ip_formated': ipv6__ip_formated = kwargs[key] elif key == 'port_real': port_real = kwargs[key] elif key == 'weight': weight = kwargs[key] elif key == 'priority': priority = kwargs[key] elif key == 'id': id = kwargs[key] return { 'id': id, 'ip': { 'id': ip__id, 'ip_formated': ip__ip_formated } if ip__id is not None and ip__ip_formated is not None else None, 'ipv6': { 'id': ip__id, 'ip_formated': ip__ip_formated } if ipv6__id is not None and ipv6__ip_formated is not None else None, 'priority': priority if priority is not None else 0, 'weight': weight if weight is not None else 0, 'limit': 0, 'port_real': port_real, 'member_status': 7, 'last_status_update_formated': None }
class TestApiEnvironmentVip(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_environment_vip = self.client.create_api_environment_vip() self.api_network_ipv4 = self.client.create_api_network_ipv4() self.api_network_ipv6 = self.client.create_api_network_ipv6() self.api_environment = self.client.create_api_environment() self.api_vlan = self.client.create_api_vlan() self.non_existent_env_vip_id = 1111 def tearDown(self): pass # get tests def test_get_an_environment_vip_by_id(self): """ Get an environment vip by id """ env = self.api_environment_vip.get([1]) assert_equal(env['environments_vip'][0]['id'], 1) def test_try_to_get_a_non_existent_environment_vip_by_id(self): """ Try to get a non existent environment vip by id """ with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([self.non_existent_env_vip_id]) # search tests def test_search_environment_vip_by_extends_search(self): """ Search expecting list with one environment vips """ finalidade_txt = 'Red' cliente_txt = 'Red' search_data = { 'extends_search': [{ 'finalidade_txt': finalidade_txt, 'cliente_txt': cliente_txt, }] } envs_vip = self.api_environment_vip.search(search=search_data) assert_equal(envs_vip['total'], 1) assert_equal( envs_vip['environments_vip'][0]['finalidade_txt'], finalidade_txt) assert_equal( envs_vip['environments_vip'][0]['cliente_txt'], cliente_txt) def test_search_a_list_of_environment_vips(self): """ Search expecting list with two environment vips """ search_data = { 'extends_search': [{ 'finalidade_txt': 'Blue', 'cliente_txt': 'Red', }, { 'finalidade_txt': 'Green', 'cliente_txt': 'Green', }] } envs_vip = self.api_environment_vip.search(search=search_data) assert_equal(envs_vip['total'], 2) for env in envs_vip['environments_vip']: assert_in(env['finalidade_txt'], ('Blue', 'Green')) assert_in(env['cliente_txt'], ('Red', 'Green')) def test_search_a_non_existent_environment_vip(self): """ Search expecting list with zero environment vips """ search_data = { 'extends_search': [{ 'finalidade_txt': 'Green', 'cliente_txt': 'Red', }] } envs = self.api_environment_vip.search(search=search_data) assert_equal(envs['total'], 0) # post tests def test_create_environment_vip(self): """ Try to create a new environment vip """ env_vip_data = { 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] env_vip = self.api_environment_vip.get([env_vip_id]) assert_equal(env_vip['environments_vip'][0]['id'], env_vip_id) self.api_environment_vip.delete([env_vip_id]) def test_create_many_environment_vips(self): """ Try to create many environment vips """ envs_vip_data = [{ 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', }, { 'finalidade_txt': 'Fin-2', 'cliente_txt': 'ClientTxt-2', 'ambiente_p44_txt': 'EnvP44Txt-2', 'description': 'Description-2', }] envs_vip_ids = self.api_environment_vip.create(envs_vip_data) envs_vip_ids = [e['id'] for e in envs_vip_ids] envs_vip = self.api_environment_vip.get(envs_vip_ids) assert_equal(len(envs_vip['environments_vip']), 2) for envs_vip in envs_vip['environments_vip']: assert_in(envs_vip['id'], envs_vip_ids) self.api_environment_vip.delete(envs_vip_ids) # put tests def test_update_environment_vip(self): """ Try to update an environment vip """ env_vip_data = { 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] env_vip = self.api_environment_vip.get( [env_vip_id])['environments_vip'][0] assert_equal(env_vip['id'], env_vip_id) new_finality_txt = env_vip['finalidade_txt'] = 'Fin-Updated' self.api_environment_vip.update([env_vip]) env_vip = self.api_environment_vip.get( [env_vip_id])['environments_vip'][0] assert_equal(env_vip['finalidade_txt'], new_finality_txt) self.api_environment_vip.delete([env_vip_id]) def test_update_a_non_existent_environment_vip(self): """ Try to update a non existent environment vip """ env_vip_data = { 'id': self.non_existent_env_vip_id, 'finalidade_txt': 'Green', 'cliente_txt': 'Red', 'description': 'Red', 'ambiente_p44_txt': 'Red', } with assert_raises(NetworkAPIClientError): self.api_environment_vip.update([env_vip_data]) # delete tests def test_delete_environment_vip(self): """ Test if we can delete an environment vip """ env_vip_data = { 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] assert_is_instance(self.api_environment_vip.get([env_vip_id]), dict) self.api_environment_vip.delete([env_vip_id]) with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id]) def test_delete_two_environments_vip(self): """ Test if we can delete two environment vips """ envs_vip_data = [ { 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', }, { 'finalidade_txt': 'Fin-2', 'cliente_txt': 'ClientTxt-2', 'ambiente_p44_txt': 'EnvP44Txt-2', 'description': 'Description-2', } ] envs_vip_id = [e['id'] for e in self.api_environment_vip.create(envs_vip_data)] assert_is_instance(self.api_environment_vip.get(envs_vip_id), dict) self.api_environment_vip.delete(envs_vip_id) for env_vip_id in envs_vip_id: with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id]) def test_delete_a_non_existent_environment_vip(self): """ Try to delete a non existent environment vip """ with assert_raises(Exception): self.api_environment_vip.delete([self.non_existent_env_vip_id]) def test_try_delete_environment_vip_assoc_with_netipv4(self): """ Try to violate delete restriction on environment vip removal when env vip is associated with some network ipv4 """ with assert_raises(Exception): self.api_environment_vip.delete([13]) def test_try_delete_environment_vip_assoc_with_netipv6(self): """ Try to violate delete restriction on environment vip removal when env vip is associated with some network ipv6 """ with assert_raises(Exception): self.api_environment_vip.delete([13]) def test_try_delete_environment_vip_assoc_to_option_vip(self): """ Try to delete environment vip associated to some option vip """ env_vip_data = { 'finalidade_txt': 'Fin-Test', 'cliente_txt': 'ClientTxt-Test', 'ambiente_p44_txt': 'EnvP44Txt-Test', 'description': 'Description-Test', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] option_vip = self.client.create_option_vip()\ .add('tipo_opcao', 'nome_opcao_txt') self.client.create_option_vip()\ .associate(option_vip['option_vip']['id'], env_vip_id) self.api_environment_vip.delete([env_vip_id]) with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id]) def test_try_delete_environment_vip_assoc_to_env(self): """ Try to delete environment vip associated to some environment """ env_vip_data = { 'finalidade_txt': 'Fin-Test', 'cliente_txt': 'ClientTxt-Test', 'ambiente_p44_txt': 'EnvP44Txt-Test', 'description': 'Description-Test', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] env = 7 self.client.create_ambiente().associate(env, env_vip_id) self.api_environment_vip.delete([env_vip_id]) with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id]) def test_try_delete_environment_vip_assoc_to_options_vip_and_envs(self): """ Try to delete environment vip associated to some options vip and environments """ env_vip_data = { 'finalidade_txt': 'Fin-Test', 'cliente_txt': 'ClientTxt-Test', 'ambiente_p44_txt': 'EnvP44Txt-Test', 'description': 'Description-Test', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] options_vip = [1, 2] environments = [7, 8] for opt in options_vip: self.client.create_option_vip().associate(opt, env_vip_id) for env in environments: self.client.create_ambiente().associate(env, env_vip_id) self.api_environment_vip.delete([env_vip_id]) with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id])
class TestApiEnvironment(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_environment = self.client.create_api_environment() def tearDown(self): pass def test_create_environment(self): """ Tries to create a new network environment """ env_data = { 'grupo_l3': 32, 'ambiente_logico': 12, 'divisao_dc': 23, 'default_vrf': 1, } env_id = self.api_environment.create([env_data])[0]['id'] env = self.api_environment.get([env_id]) assert_equal(env['environments'][0]['id'], env_id) self.api_environment.delete([env_id]) def test_create_many_environments(self): """ Tries to create many environments """ envs_data = [{ 'grupo_l3': 32, 'ambiente_logico': 12, 'divisao_dc': 23, 'default_vrf': 1, }, { 'grupo_l3': 32, 'ambiente_logico': 11, 'divisao_dc': 25, 'default_vrf': 1, }] envs_ids = [e['id'] for e in self.api_environment.create(envs_data)] envs = self.api_environment.get(envs_ids) assert_equal(len(envs['environments']), 2) for env in envs['environments']: assert_in(env['id'], envs_ids) self.api_environment.delete(envs_ids) def test_insert_a_duplicated_environment(self): """ Tries to insert a duplicated environment """ env_data = { 'grupo_l3': 32, 'ambiente_logico': 12, 'divisao_dc': 22, 'default_vrf': 1, } with assert_raises(NetworkAPIClientError): self.api_environment.create([env_data]) def test_delete_environment(self): """ Tests if we can delete an environment """ env_data = { 'grupo_l3': 32, 'ambiente_logico': 12, 'divisao_dc': 23, 'default_vrf': 1, } env_id = self.api_environment.create([env_data])[0]['id'] assert_is_instance(self.api_environment.get([env_id]), dict) self.api_environment.delete([env_id]) with assert_raises(NetworkAPIClientError): self.api_environment.get([env_id]) def test_delete_a_non_existent_environment(self): """ Tries to delete a non existent environment """ with assert_raises(NetworkAPIClientError): self.api_environment.delete([1111]) def test_search_an_environment(self): """ Searches an environment """ dc_division = 25 logic_env = 15 search_data = { 'extends_search': [{ 'divisao_dc': dc_division, 'ambiente_logico': logic_env, }] } envs = self.api_environment.search(search=search_data) assert_equal(envs['total'], 1) assert_equal(envs['environments'][0]['divisao_dc'], dc_division) assert_equal(envs['environments'][0]['ambiente_logico'], logic_env) def test_search_a_list_of_environments(self): """ Searches a list of environment """ search_data = { 'extends_search': [{ 'divisao_dc': 25, 'ambiente_logico': 15, }, { 'divisao_dc': 24, 'ambiente_logico': 14, }] } envs = self.api_environment.search(search=search_data) assert_equal(envs['total'], 2) for env in envs['environments']: assert_in(env['divisao_dc'], (25, 24)) assert_in(env['ambiente_logico'], (15, 14)) def test_search_a_non_existent_environment(self): """ Searches a non existent environment """ search_data = { 'extends_search': [{ 'divisao_dc': 100, 'ambiente_logico': 100, }] } envs = self.api_environment.search(search=search_data) assert_equal(envs['total'], 0) def test_get_an_environment_by_id(self): """ Get an enviroment by id """ env = self.api_environment.get([1]) assert_equal(env['environments'][0]['id'], 1) def test_try_to_get_a_non_existent_environment_by_id(self): """ Tries to get a non existent environment by id """ with assert_raises(NetworkAPIClientError): self.api_environment.get([1000]) def test_update_an_environment(self): """ Updates an environment """ env_data = { 'grupo_l3': 32, 'ambiente_logico': 12, 'divisao_dc': 21, 'default_vrf': 1, } env_id = self.api_environment.create([env_data])[0]['id'] env = self.api_environment.get([env_id])['environments'][0] assert_equal(env['id'], env_id) new_dc_division = env['divisao_dc'] = 23 self.api_environment.update([env]) env = self.api_environment.get([env_id])['environments'][0] assert_equal(env['divisao_dc'], new_dc_division) self.api_environment.delete([env_id]) def test_update_a_non_existent_environment(self): """ Tries to update a non existent environment """ env_data = { 'id': 1000, 'grupo_l3': 32, 'ambiente_logico': 12, 'divisao_dc': 21, 'default_vrf': 1, } with assert_raises(NetworkAPIClientError): self.api_environment.update([env_data])
class ApiNetworksTestCase(TestCase): def setUp(self): self.networkapi_url = os.getenv( 'NETWORKAPI_URL', 'http://10.0.0.2:8000/') self.networkapi_user = os.getenv( 'NETWORKAPI_USER', 'networkapi') self.networkapi_pwd = os.getenv('NETWORKAPI_PWD', 'networkapi') self.client_api = ClientFactory( self.networkapi_url, self.networkapi_user, self.networkapi_pwd) self.sufix = time() self.configs() self.objects = dict() def tearDown(self): try: # Removes Vlans of Racks self.remove_all_vlans([self.objects['id_envrk_A']]) self.remove_all_vlans([self.objects['id_envrk_B']]) self.remove_all_vlans([self.objects['id_envrk_C']]) self.remove_all_vlans([self.objects['id_envrk_D']]) except: pass try: # Removes environment of load balancing self.client_api.create_api_environment()\ .delete(self.objects['id_envlb']) # Removes environment of racks self.client_api.create_api_environment()\ .delete(self.objects['id_envrk_A']) self.client_api.create_api_environment()\ .delete(self.objects['id_envrk_B']) self.client_api.create_api_environment()\ .delete(self.objects['id_envrk_C']) self.client_api.create_api_environment()\ .delete(self.objects['id_envrk_D']) except: pass # Removes vrfs try: self.client_api.create_api_vrf().delete(self.objects['id_vrf']) except: pass # Removes Environment DC for id_envdc in self.objects['id_envdc']: try: self.client_api.create_divisao_dc().remover(id_envdc) except: pass # Removes Environment Logic for id_envlog in self.objects['id_envlog']: try: self.client_api.create_ambiente_logico().remover(id_envlog) except: pass # Removes Environment layer 3 for load balancing for id_envl3 in self.objects['id_envl3']: try: self.client_api.create_grupo_l3().remover(id_envl3) except: pass # Removes eqpts try: self.client_api.create_api_create().delete(self.objects['id_eqpt']) except: pass def test_create_networkv4_by_zero(self): """ Test of integration for create environment, vlan, eqpt networks v4. ################## Starting test: - environment A: - eqpt 1, 2, 3 - vrf 1 - starting vlans 1,2,3 - environment B: - eqpt 2, 4, 5 - vrf 1 - starting vlans 4, 5, 6, 7, 8, 9 - environment C: - EQpt 5, 6 - vrf 2 - startinG vlans 10, 11 - environment D: - eqpt 7 - vrf 1 - starting vlans 1 ################## ################## Inserting new vlans without numbers: - environment A: Expected 10 - environment B: Expected 12 - environment C: Expected 1 - environment C: Expected 2 - environment C: Expected 3 - environment C: Expected 13 - environment B: Expected 14 - environment B: Expected 15 - environment B: Expected 16 - environment A: Expected 11 - environment A: Expected 13 - environment A: Expected 17 - environment A: Expected 18 - environment B: Expected 19 - environment C: Expected 17 - environment D: Expected 1 ################## ################## Starting networks: environment A: Nothing environment B: 10.0.1.0/24 10.0.2.0/25 10.0.3.0/24 environment C: Nothing environment D: Nothing ################## ################## Inserting networks without octs: - environment B: Expected 10.0.0.0/24 - environment C: Expected 10.0.0.0/25 - environment C using prefix 24: Expected 10.0.1.0/24 - environment A: Expected 10.0.2.128/25 - environment A: Expected 10.0.4.0/25 - environment B: Expected 10.0.5.0/24 - environment A: Expected 10.0.4.128/25 - environment D: Expected 10.0.0.0/24 ################## """ # Creates VRF 1 id_vrf_a = self.create_vrf('BeTeste-1') self.objects['id_vrf'] = [id_vrf_a] # Creates VRF 2 id_vrf_b = self.create_vrf('BeTeste-2') self.objects['id_vrf'].append(id_vrf_b) # Creates Environment DC and Logic id_envdc = self.create_envdc('BE-TESTE') id_envlog = self.create_envlog('TESTE') self.objects['id_envdc'] = [id_envdc] self.objects['id_envlog'] = [id_envlog] # Creates environment layer 3 for load balancing id_envl3 = self.create_envl3('BALANCEAMENTO-POOL') self.objects['id_envl3'] = [id_envl3] # Creates environment of load balancing id_env = self.create_env(id_envl3, id_envlog, id_envdc, id_vrf_a, self.configs['env_lb']) self.objects['id_envlb'] = [id_env] env_list = {'A': id_vrf_a, 'B': id_vrf_a, 'C': id_vrf_b, 'D': id_vrf_a} # Creates environments of racks for i in env_list: # Creates environment layer 3 for racks id_envl3 = self.create_envl3('RACK-%s' % i) self.objects['id_envl3'].append(id_envl3) id_env = self.create_env(id_envl3, id_envlog, id_envdc, env_list[i], self.configs[i]) self.objects['id_envrk_' + i] = id_env # Creates equipments with relationship environments self.create_equipments() # Creates vlans with numbers self.create_vlans_with_number_envs() # Creates vlans with auto numbers self.create_vlans_without_number() # Creates networks v4 with octs self.create_netv4_with_octs() # Creates networks with auto octs and prefix self.create_netv4_without_octs() def test_create_networkv6_by_zero(self): """ Test of integration for create environment, vlan, eqpt networks v6. ################## Starting test: - environment A: - eqpt 1, 2, 3 - vrf 1 - starting vlans 1,2,3 - environment B: - eqpt 2, 4, 5 - vrf 1 - starting vLANS 4, 5, 6, 7, 8, 9 - environment C: - EQpt 5, 6 - vrf 2 - startinG VLANS 10, 11 - environment D: - eqpt 7 - vrf 1 - starting vlans 1 ################## ################## Inserting new vlans: - environment A: 10 - environment B: 12 - environment C: 1 - environment C: 2 - environment C: 3 - environment C: 13 - environment B: 14 - environment B: 15 - environment B: 16 - environment A: 11 - environment A: 13 - environment A: 17 - environment A: 18 - environment B: 19 - environment C: 17 - environment D: 1 ################## ################## Starting networks: environment A: Nothing environment B: fdbe:bebe:bebe:1201:0000:0000:0000:0000/64 fdbe:bebe:bebe:1202:0000:0000:0000:0000/65 fdbe:bebe:bebe:1203:0000:0000:0000:0000/64 environment C: Nothing environment D: Nothing ################## ################## Inserting networks: - environment B:fdbe:bebe:bebe:1200:0000:0000:0000:0000/64 - environment C:fdbe:bebe:bebe:1200:0000:0000:0000:0000/65 - environment C using prefix 24: fdbe:bebe:bebe:1201:0000:0000:0000:0000/64 - environment A:fdbe:bebe:bebe:1202:8000:0000:0000:0000/65 - environment A:fdbe:bebe:bebe:1204:0000:0000:0000:0000/65 - environment B:fdbe:bebe:bebe:1205:0000:0000:0000:0000/64 - environment A:fdbe:bebe:bebe:1204:8000:0000:0000:0000/65 - environment D:fdbe:bebe:bebe:1200:0000:0000:0000:0000/64 ################## """ # Creates VRF 1 id_vrf_a = self.create_vrf('BeTeste-1') self.objects['id_vrf'] = [id_vrf_a] # Creates VRF 2 id_vrf_b = self.create_vrf('BeTeste-2') self.objects['id_vrf'].append(id_vrf_b) # Creates Environment DC and Logic id_envdc = self.create_envdc('BE-TESTE') id_envlog = self.create_envlog('TESTE') self.objects['id_envdc'] = [id_envdc] self.objects['id_envlog'] = [id_envlog] # Creates environment layer 3 for load balancing id_envl3 = self.create_envl3('BALANCEAMENTO-POOL') self.objects['id_envl3'] = [id_envl3] # Creates environment of load balancing id_env = self.create_env(id_envl3, id_envlog, id_envdc, id_vrf_a, self.configs['env_lb']) self.objects['id_envlb'] = [id_env] env_list = {'A': id_vrf_a, 'B': id_vrf_a, 'C': id_vrf_b, 'D': id_vrf_a} # Creates environments of racks for i in env_list: # Creates environment layer 3 for racks id_envl3 = self.create_envl3('RACK-%s' % i) self.objects['id_envl3'].append(id_envl3) id_env = self.create_env(id_envl3, id_envlog, id_envdc, env_list[i], self.configs[i]) self.objects['id_envrk_' + i] = id_env # Creates equipments with relationship environments self.create_equipments() # Creates vlans with numbers self.create_vlans_with_number_envs() # Creates vlans with auto numbers self.create_vlans_without_number() # Creates networks with octs self.create_netv6_with_octs() # Creates networks with auto octs and prefix self.create_netv6_without_octs() def configs(self): self.configs = { 'env_lb': [{ 'subnet': 'febe:bebe:bebe:8200:0:0:0:0/57', 'new_prefix': '64', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.10.0.0/16', 'new_prefix': '24', 'type': 'v4', 'network_type': 8 }], 'A': [{ 'subnet': 'fdbe:bebe:bebe:1200:0000:0000:0000:0000/57', 'new_prefix': '65', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.0.0.0/16', 'new_prefix': '25', 'type': 'v4', 'network_type': 8 }], 'B': [{ 'subnet': 'fdbe:bebe:bebe:1200:0000:0000:0000:0000/57', 'new_prefix': '64', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.0.0.0/16', 'new_prefix': '24', 'type': 'v4', 'network_type': 8 }], 'C': [{ 'subnet': 'fdbe:bebe:bebe:1200:0000:0000:0000:0000/57', 'new_prefix': '65', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.0.0.0/16', 'new_prefix': '25', 'type': 'v4', 'network_type': 8 }], 'D': [{ 'subnet': 'fdbe:bebe:bebe:1200:0000:0000:0000:0000/57', 'new_prefix': '64', 'type': 'v6', 'network_type': 8 }, { 'subnet': '10.0.0.0/16', 'new_prefix': '24', 'type': 'v4', 'network_type': 8 }] } def create_envdc(self, name): """Creates Environment DC""" id_envdc = self.client_api.create_divisao_dc()\ .inserir('%s-%s' % (name, self.sufix))['division_dc']['id'] return id_envdc def create_envlog(self, name): """Creates Environment Logic""" id_envlog = self.client_api.create_ambiente_logico()\ .inserir('%s-%s' % (name, self.sufix))['logical_environment']['id'] return id_envlog def create_envl3(self, name): """Creates environment layer 3 for load balancing.""" id_envl3 = self.client_api.create_grupo_l3()\ .inserir('%s-%s' % (name, self.sufix))['group_l3']['id'] return id_envl3 def create_vrf(self, name): """Creates VRF.""" vrf_dict = [{ 'internal_name': '%s-%s' % (name, self.sufix), 'vrf': '%s-%s' % (name, self.sufix) }] id_vrf = self.client_api.create_api_vrf()\ .create(vrf_dict)[0]['id'] return id_vrf def create_env(self, id_envl3, id_envlog, id_envdc, id_vrf, configs): """Creates environment.""" env_dict = [{ 'grupo_l3': int(id_envl3), 'ambiente_logico': int(id_envlog), 'divisao_dc': int(id_envdc), 'filter': 1, 'default_vrf': id_vrf, 'min_num_vlan_1': 1, 'max_num_vlan_1': 500, 'min_num_vlan_2': 1000, 'max_num_vlan_2': 1500, 'configs': configs }] id_env = self.client_api.create_api_environment()\ .create(env_dict)[0]['id'] return id_env def create_equipments(self): """Creates equipments.""" eqpt_dict = [{ 'name': 'TESTE-EQUIP-1%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_A'] }] }, { 'name': 'TESTE-EQUIP-2%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_A'] }] }, { 'name': 'TESTE-EQUIP-3%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_A'] }, { 'is_router': False, 'environment': self.objects['id_envrk_B'] }] }, { 'name': 'TESTE-EQUIP-4%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_B'] }] }, { 'name': 'TESTE-EQUIP-5%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_B'] }, { 'is_router': False, 'environment': self.objects['id_envrk_C'] }] }, { 'name': 'TESTE-EQUIP-6%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_C'] }] }, { 'name': 'TESTE-EQUIP-7%s' % self.sufix, 'maintenance': False, 'equipment_type': 3, 'model': 1, 'environments': [{ 'is_router': False, 'environment': self.objects['id_envrk_D'] }] }] ids = self.client_api.create_api_equipment().create(eqpt_dict) self.objects['id_eqpt'] = ids def create_vlans_without_number(self): """Creates vlans without number.""" id_env_a = self.objects['id_envrk_A'] id_env_b = self.objects['id_envrk_B'] id_env_c = self.objects['id_envrk_C'] id_env_d = self.objects['id_envrk_D'] list_envs_alocate_vlans = [ id_env_a, id_env_b, id_env_c, id_env_c, id_env_c, id_env_c, id_env_b, id_env_b, id_env_b, id_env_a, id_env_a, id_env_a, id_env_a, id_env_b, id_env_c, id_env_d ] list_expected_num_vlans = [ 10, 12, 1, 2, 3, 13, 14, 15, 16, 11, 13, 17, 18, 19, 17, 1 ] vlans = [] for i, id_env in enumerate(list_envs_alocate_vlans): vlan = [{ 'name': 'Vlan auto %s - %s' % (i, self.sufix), 'environment': id_env }] id_vlan = [self.client_api.create_api_vlan().create(vlan)[0]['id']] vlan_obj = self.client_api.create_api_vlan().get(id_vlan)[ 'vlans'][0] vlans.append(vlan_obj) self.verify_num_vlan(vlans, list_expected_num_vlans) def create_vlans_with_number(self, nums_vlan, id_env): """Creates vlans with number.""" vlans = [] for num_vlan in nums_vlan: vlan = [{ 'name': 'Vlan %s' % (num_vlan), 'environment': id_env, 'num_vlan': num_vlan }] id_vlan = [self.client_api.create_api_vlan().create(vlan)[0]['id']] vlan_obj = self.client_api.create_api_vlan().get(id_vlan)[ 'vlans'][0] vlans.append(vlan_obj) return vlans def create_vlans_with_number_envs(self): """Creates vlans with number for environments A, B and C.""" id_env_a = self.objects['id_envrk_A'] id_env_b = self.objects['id_envrk_B'] id_env_c = self.objects['id_envrk_C'] # Environment A # [1, 2, 3] nums_vlan = range(1, 4) # Creates Vlans id_vlans = self.create_vlans_with_number(nums_vlan, id_env_a) ids = [id_vlan['id'] for id_vlan in id_vlans] # Get Vlans vlans = self.client_api.create_api_vlan().get(ids)['vlans'] # Verify num vlans was created self.verify_num_vlan(vlans, nums_vlan) # Environment B # [4, 5, 6, 7, 8, 9] nums_vlan = range(4, 10) # Creates Vlans id_vlans = self.create_vlans_with_number(nums_vlan, id_env_b) ids = [id_vlan['id'] for id_vlan in id_vlans] # Get Vlans vlans = self.client_api.create_api_vlan().get(ids)['vlans'] # Verify num vlans was created self.verify_num_vlan(vlans, nums_vlan) # Environment C # [10, 11] nums_vlan = range(10, 12) # Creates Vlans id_vlans = self.create_vlans_with_number(nums_vlan, id_env_c) ids = [id_vlan['id'] for id_vlan in id_vlans] # Get Vlans vlans = self.client_api.create_api_vlan().get(ids)['vlans'] # Verify num vlans was created self.verify_num_vlan(vlans, nums_vlan) def verify_num_vlan(self, objs, nums_vlan): for obj, num_vlan in izip(objs, nums_vlan): self.assertEqual( num_vlan, obj.get('num_vlan'), 'Num vlan should be %s was %s' % ( num_vlan, obj.get('num_vlan')) ) def search_all_vlans(self, ids_env): search_vlan = { 'start_record': 0, 'end_record': 100, 'asorting_cols': [], 'searchable_columns': [], 'extends_search': [ {'ambiente': id_env} for id_env in ids_env ] } vlans = self.client_api.create_api_vlan()\ .search(search=search_vlan, fields=['id'])['vlans'] ids_vlans = [id_vlan['id'] for id_vlan in vlans] return ids_vlans def remove_all_vlans(self, ids_env): ids_vlans = self.search_all_vlans(ids_env) if ids_vlans: search_net = { 'start_record': 0, 'end_record': 100, 'asorting_cols': [], 'searchable_columns': [], 'extends_search': [{'vlan': id_vlan} for id_vlan in ids_vlans] } networks = self.client_api.create_api_network_ipv4()\ .search(search=search_net, fields=['id'])['networks'] ids_networks = [id['id'] for id in networks] if ids_networks: self.client_api.create_api_network_ipv4().delete(ids_networks) networks = self.client_api.create_api_network_ipv6()\ .search(search=search_net, fields=['id'])['networks'] ids_networks = [id['id'] for id in networks] if ids_networks: self.client_api.create_api_network_ipv6().delete(ids_networks) self.client_api.create_api_vlan().delete(ids_vlans) def create_netv4_with_octs(self): """Creates networks v4 using first vlan.""" networks = [{ 'oct1': 10, 'oct2': 0, 'oct3': 1, 'oct4': 0, 'prefix': 24, 'env': self.objects['id_envrk_B'] }, { 'oct1': 10, 'oct2': 0, 'oct3': 2, 'oct4': 0, 'prefix': 25, 'env': self.objects['id_envrk_B'] }, { 'oct1': 10, 'oct2': 0, 'oct3': 3, 'oct4': 0, 'prefix': 24, 'env': self.objects['id_envrk_B'] }] fields = [ 'oct1', 'oct2', 'oct3', 'oct4', 'prefix', 'vlan' ] for network_send in networks: # Get all vlans of environment ids_vlans = self.search_all_vlans([network_send.get('env')]) del network_send['env'] # Creates networks v4 network_send['vlan'] = ids_vlans[0] network = [{ 'oct1': network_send.get('oct1'), 'oct2': network_send.get('oct2'), 'oct3': network_send.get('oct3'), 'oct4': network_send.get('oct4'), 'prefix': network_send.get('prefix'), 'vlan': network_send.get('vlan'), 'network_type': 6, 'environmentvip': None }] id_network = self.client_api.create_api_network_ipv4()\ .create(network)[0]['id'] # Get object created network_rec = self.client_api.create_api_network_ipv4()\ .get([id_network], fields=fields)['networks'][0] # Verify if object is right self.assertDictEqual( network_send, network_rec, 'Network should be %s and was %s' % (network_send, network_rec) ) def create_netv4_without_octs(self): networks = [ { 'prefix': None, 'env': self.objects['id_envrk_B'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_C'], 'network_type': 6, 'environmentvip': None }, { 'prefix': 24, 'env': self.objects['id_envrk_C'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_B'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_D'], 'network_type': 6, 'environmentvip': None } ] expected_networks = [ { 'oct1': 10, 'oct2': 0, 'oct3': 0, 'oct4': 0, 'prefix': 24, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 0, }, { 'oct1': 10, 'oct2': 0, 'oct3': 0, 'oct4': 0, 'prefix': 25, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 128, }, { 'oct1': 10, 'oct2': 0, 'oct3': 1, 'oct4': 0, 'prefix': 24, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 0, }, { 'oct1': 10, 'oct2': 0, 'oct3': 2, 'oct4': 128, 'prefix': 25, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 128 }, { 'oct1': 10, 'oct2': 0, 'oct3': 4, 'oct4': 0, 'prefix': 25, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 128 }, { 'oct1': 10, 'oct2': 0, 'oct3': 5, 'oct4': 0, 'prefix': 24, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 0 }, { 'oct1': 10, 'oct2': 0, 'oct3': 4, 'oct4': 128, 'prefix': 25, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 128 }, { 'oct1': 10, 'oct2': 0, 'oct3': 0, 'oct4': 0, 'prefix': 24, 'mask_oct1': 255, 'mask_oct2': 255, 'mask_oct3': 255, 'mask_oct4': 0 } ] fields = [ 'oct1', 'oct2', 'oct3', 'oct4', 'prefix', 'mask_oct1', 'mask_oct2', 'mask_oct3', 'mask_oct4', ] for network_send, expected_network in izip(networks, expected_networks): # Get all vlans of environment ids_vlans = self.search_all_vlans([network_send.get('env')]) # Creates networks v4 network_send['vlan'] = ids_vlans[0] id_network = self.client_api.create_api_network_ipv4()\ .create([network_send])[0]['id'] network_rec = self.client_api.create_api_network_ipv4()\ .get([id_network], fields=fields)['networks'][0] self.assertDictEqual( expected_network, network_rec, 'Network should be %s and was %s' % ( expected_network, network_rec) ) def create_netv6_with_octs(self): """Creates networks v6 using first vlan.""" networks = [{ 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1201', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000', 'env': self.objects['id_envrk_B'] }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1202', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000', 'env': self.objects['id_envrk_B'] }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1203', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000', 'env': self.objects['id_envrk_B'] }] fields = [ 'block1', 'block2', 'block3', 'block4', 'block5', 'block6', 'block7', 'block8', 'prefix', 'mask1', 'mask2', 'mask3', 'mask4', 'mask5', 'mask6', 'mask7', 'mask8', 'vlan' ] for network_send in networks: # Get all vlans of environment ids_vlans = self.search_all_vlans([network_send.get('env')]) del network_send['env'] # Creates networks v4 network_send['vlan'] = ids_vlans[0] network = [{ 'block1': network_send.get('block1'), 'block2': network_send.get('block2'), 'block3': network_send.get('block3'), 'block4': network_send.get('block4'), 'block5': network_send.get('block5'), 'block6': network_send.get('block6'), 'block7': network_send.get('block7'), 'block8': network_send.get('block8'), 'prefix': network_send.get('prefix'), 'vlan': network_send.get('vlan'), 'network_type': 6, 'environmentvip': None }] id_network = self.client_api.create_api_network_ipv6()\ .create(network)[0]['id'] # Get object created network_rec = self.client_api.create_api_network_ipv6()\ .get([id_network], fields=fields)['networks'][0] # Verify if object is right self.assertDictEqual( network_send, network_rec, 'Network should be %s and was %s' % (network_send, network_rec) ) def create_netv6_without_octs(self): networks = [ { 'prefix': None, 'env': self.objects['id_envrk_B'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_C'], 'network_type': 6, 'environmentvip': None }, { 'prefix': 64, 'env': self.objects['id_envrk_C'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_B'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_A'], 'network_type': 6, 'environmentvip': None }, { 'prefix': None, 'env': self.objects['id_envrk_D'], 'network_type': 6, 'environmentvip': None } ] expected_networks = [{ 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1200', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1200', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1201', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1202', 'block5': '8000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1204', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1205', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1204', 'block5': '8000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 65, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '8000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }, { 'block1': 'fdbe', 'block2': 'bebe', 'block3': 'bebe', 'block4': '1200', 'block5': '0000', 'block6': '0000', 'block7': '0000', 'block8': '0000', 'prefix': 64, 'mask1': 'ffff', 'mask2': 'ffff', 'mask3': 'ffff', 'mask4': 'ffff', 'mask5': '0000', 'mask6': '0000', 'mask7': '0000', 'mask8': '0000' }] fields = [ 'block1', 'block2', 'block3', 'block4', 'block5', 'block6', 'block7', 'block8', 'prefix', 'mask1', 'mask2', 'mask3', 'mask4', 'mask5', 'mask6', 'mask7', 'mask8' ] for network_send, expected_network in izip(networks, expected_networks): # Get all vlans of environment ids_vlans = self.search_all_vlans([network_send.get('env')]) # Creates networks v4 network_send['vlan'] = ids_vlans[0] id_network = self.client_api.create_api_network_ipv6()\ .create([network_send])[0]['id'] network_rec = self.client_api.create_api_network_ipv6()\ .get([id_network], fields=fields)['networks'][0] self.assertDictEqual( expected_network, network_rec, 'Network should be %s and was %s' % ( expected_network, network_rec) )
def lost_pass(request): form = LoginForm() modal_auto_open = "true" try: if request.method == 'POST': form_pass = PassForm(request.POST) if form_pass.is_valid(): client = ClientFactory( NETWORK_API_URL, NETWORK_API_USERNAME, NETWORK_API_PASSWORD) users = client.create_usuario().listar() users = users.get("usuario") username = form_pass.cleaned_data['username'] email = form_pass.cleaned_data['email'] for user in users: if user.get("user").upper() == username.upper(): if user.get("email") == email: if not user.get('user_ldap'): pass_open = make_random_password() password = hashlib.md5(pass_open).hexdigest() ativo = None if user.get('ativo'): ativo = '1' else: ativo = '0' client.create_usuario().alterar(user.get('id'), user.get('user'), password, user.get('nome'), ativo, user.get('email'), user.get('user_ldap')) lists = dict() lists['user'] = user.get('user') lists['new_pass'] = pass_open # Montar Email com nova senha connection = EmailBackend( username=EMAIL_HOST_USER, password=EMAIL_HOST_PASSWORD) send_email = EmailMessage('Solicitação de Nova Senha', loader.render_to_string( MAIL_NEW_PASS, lists), EMAIL_FROM, [email], connection=connection) send_email.content_subtype = "html" send_email.send() messages.add_message( request, messages.SUCCESS, auth_messages.get("email_success")) modal_auto_open = 'false' return render_to_response(templates.LOGIN, {'form': form, 'form_pass': form_pass, 'modal': modal_auto_open}, context_instance=RequestContext(request)) else: messages.add_message( request, messages.ERROR, auth_messages.get("user_ldap_cant_recover_pass")) modal_auto_open = 'false' return render_to_response(templates.LOGIN, {'form': form, 'form_pass': form_pass, 'modal': modal_auto_open}, context_instance=RequestContext(request)) for user in users: if user.get("user_ldap") is not None and user.get("user_ldap").upper() == username.upper(): messages.add_message( request, messages.ERROR, auth_messages.get("user_ldap_cant_recover_pass")) modal_auto_open = 'false' return render_to_response(templates.LOGIN, {'form': form, 'form_pass': form_pass, 'modal': modal_auto_open}, context_instance=RequestContext(request)) messages.add_message( request, messages.ERROR, auth_messages.get("user_email_invalid")) modal_auto_open = 'false' except NetworkAPIClientError, e: logger.error(e) messages.add_message(request, messages.ERROR, e) modal_auto_open = 'false'
class NetworkAPI(object): logger = logging.getLogger(__name__) def __init__(self): self.client = ClientFactory(NETWORKAPI_ENDPOINT, NETWORKAPI_USER, NETWORKAPI_PASSWORD) def _log_debug_request(self, func, param_id): self.logger.debug('[DriverNapi][request] %s %s' % (func, param_id)) def _log_debug_response(self, func, param_id, response): self.logger.debug('[DriverNapi][response] %s %s/n%s' % (func, param_id, response)) def _log_warning_response(self, func, param_id, response): self.logger.warning('[DriverNapi][response] %s %s/n%s' % (func, param_id, response)) def get_pool(self, pool_id): """Return Pool""" try: response = self.client.create_api_pool().get(ids=[pool_id], kind='details') except NetworkAPIClientError as err: self._log_warning_response('get_pool', pool_id, err) return [] else: self._log_debug_response('get_pool', pool_id, response) pools = response.get('server_pools') if pools: pools = pools[0] return pools def get_pool_by_member_id(self, member_id): """Return Pool by member id""" self._log_debug_request('get_pool_by_member_id', member_id) try: response = self.client.create_api_pool().search( search={'extends_search': [{ 'serverpoolmember': member_id }]}, kind='details') except NetworkAPIClientError as err: self._log_warning_response('get_pool_by_member_id', member_id, err) return [] else: self._log_debug_response('get_pool_by_member_id', member_id, response) pools = response.get('server_pools') if pools: pools = pools[0] return pools def get_vip(self, vip_id): """Return VIP""" self._log_debug_request('get_vip', vip_id) try: response = self.client.create_api_vip_request().get(ids=[vip_id], kind='details') except NetworkAPIClientError as err: self._log_warning_response('get_vip', vip_id, err) return [] else: self._log_debug_response('get_vip', vip_id, response) vips = response.get('vips') if vips: vips = vips[0] return vips def get_vip_by_portpool_id(self, portpool_id): """Return VIP by port pool id""" self._log_debug_request('get_vip_by_portpool_id', portpool_id) try: response = self.client.create_api_vip_request().search( search={ 'extends_search': [{ 'viprequestport__viprequestportpool': portpool_id }] }, kind='details') except NetworkAPIClientError as err: self._log_warning_response('get_vip_by_portpool_id', portpool_id, err) return [] else: self._log_debug_response('get_vip_by_portpool_id', portpool_id, response) vips = response.get('vips') if vips: vips = vips[0] return vips def get_equipment(self, equipment_id): """Return Equipment""" self._log_debug_request('get_equipment', equipment_id) try: response = self.client.create_api_equipment().get( ids=[equipment_id], include=[ 'equipment_type__details', 'ipv4__basic__networkipv4', 'ipv6__basic__networkipv6' ]) except NetworkAPIClientError as err: self._log_warning_response('get_equipment', equipment_id, err) return [] else: self._log_debug_response('get_equipment', equipment_id, response) equipments = response.get('equipments') if equipments: equipments = equipments[0] return equipments def get_network_ipv4_id(self, net_id): """Return NetworkIpv4""" self._log_debug_request('get_network_ipv4_id', net_id) try: response = self.client.create_api_network_ipv4().get( ids=[net_id], fields=[ 'id', 'network_type__details', 'active', 'networkv4', 'vlan__basic' ]) except NetworkAPIClientError as err: self._log_warning_response('get_network_ipv4_id', net_id, err) return [] else: self._log_debug_response('get_network_ipv4_id', net_id, response) networks = response.get('networks') if networks: networks = networks[0] return networks def get_network_ipv6_id(self, net_id): """Return NetworkIpv6""" self._log_debug_request('get_network_ipv4_id', net_id) try: response = self.client.create_api_network_ipv6().get( ids=[net_id], fields=[ 'id', 'network_type__details', 'active', 'networkv6', 'vlan__basic' ]) except NetworkAPIClientError as err: self._log_warning_response('get_network_ipv4_id', net_id, err) return [] else: self._log_debug_response('get_network_ipv4_id', net_id, response) networks = response.get('networks') if networks: networks = networks[0] return networks def get_ipv4_by_ip_equipment_id(self, ip_equipment_id): """Return Ipv4 by ip equipment id""" self._log_debug_request('get_ipv4_by_ip_equipment_id', ip_equipment_id) try: response = self.client.create_api_ipv4().search( search={ 'extends_search': [{ 'ipequipamento': ip_equipment_id }] }, fields=['networkipv4', 'ip_formated']) except NetworkAPIClientError as err: self._log_warning_response('get_ipv4_by_ip_equipment_id', ip_equipment_id, err) return [] else: self._log_debug_response('get_ipv4_by_ip_equipment_id', ip_equipment_id, response) ips = response.get('ips') if ips: ips = ips[0] return ips def get_ipv6_by_ip_equipment_id(self, ip_equipment_id): """Return Ipv6 by ip equipment id""" self._log_debug_request('get_ipv6_by_ip_equipment_id', ip_equipment_id) try: response = self.client.create_api_ipv6().search( search={ 'extends_search': [{ 'ipv6equipament': ip_equipment_id }] }, fields=['networkipv6', 'ip_formated']) except NetworkAPIClientError as err: self._log_warning_response('get_ipv6_by_ip_equipment_id', ip_equipment_id, err) return [] else: self._log_debug_response('get_ipv6_by_ip_equipment_id', ip_equipment_id, response) ips = response.get('ips') if ips: ips = ips[0] return ips def get_vlan(self, vlan_id): """Return Vlan""" self._log_debug_request('get_vlan', vlan_id) try: response = self.client.create_api_vlan().get( ids=[vlan_id], include=['environment__basic']) except NetworkAPIClientError as err: self._log_warning_response('get_vlan', vlan_id, err) return [] else: self._log_debug_response('get_vlan', vlan_id, response) vlans = response.get('vlans') if vlans: vlans = vlans[0] return vlans def get_environment(self, environment_id): """Return Environment""" self._log_debug_request('get_environment', environment_id) try: response = self.client.create_api_environment().get( ids=[environment_id], include=['default_vrf__details', 'father_environment__basic']) except NetworkAPIClientError as err: self._log_warning_response('get_environment', environment_id, err) return [] else: self._log_debug_response('get_environment', environment_id, response) environments = response.get('environments') if environments: environments = environments[0] return environments
class TestApiVlan(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_vlan = self.client.create_api_vlan() def test_search_a_vlan(self): """ Tests the vlan search """ vlan_name = 'Vlan 31' search_data = { 'extends_search': [{ 'nome': vlan_name }] } vlans = self.api_vlan.search(search=search_data) assert_equal(vlans['total'], 1) assert_equal(vlans['vlans'][0]['name'], vlan_name) def test_get_vlans_by_id(self): """ Gets vlans by ids """ vlans_ids = [1, 3, 5] vlans = self.api_vlan.get(vlans_ids) assert_equal(len(vlans['vlans']), 3) for vlan in vlans['vlans']: assert_in(vlan['id'], vlans_ids) def test_get_only_one_vlan_by_id(self): """ Gets only one vlan by its id """ vlan_id = 7 vlan = self.api_vlan.get([vlan_id]) assert_equal(len(vlan['vlans']), 1) assert_equal(vlan['vlans'][0]['id'], vlan_id) def test_get_a_non_existing_vlan(self): """ Attenpts to get a non existing vlan """ vlan_id = 15 with assert_raises(NetworkAPIClientError): vlan = self.api_vlan.get([vlan_id]) def test_insert_new_vlan(self): """ Tries to insert a new vlan """ vlan_data = { 'name': 'Vlan 15', 'environment': 1, } vlan_id = self.api_vlan.create([vlan_data])[0]['id'] vlan = self.api_vlan.get([vlan_id]) assert_equal(len(vlan['vlans']), 1) assert_equal(vlan['vlans'][0]['id'], vlan_id) self.api_vlan.delete([vlan_id]) def test_insert_a_duplicated_vlan(self): """ Tries to insert a duplicated vlan """ vlan_data = { 'name': 'Vlan 25', 'environment': 1, 'num_vlan': 15, } vlan_id = self.api_vlan.create([vlan_data])[0]['id'] with assert_raises(NetworkAPIClientError): self.api_vlan.create([vlan_data]) self.api_vlan.delete([vlan_id]) def test_insert_a_list_of_vlans(self): """ Tries to insert a list of vlans """ vlans_data = [{ 'name': 'Vlan 40', 'environment': 1, }, { 'name': 'Vlan 41', 'environment': 2, }, { 'name': 'Vlan 42', 'environment': 2, }] vlans_ids = [vlan['id'] for vlan in self.api_vlan.create(vlans_data)] vlans = self.api_vlan.get(vlans_ids) assert_equal(len(vlans['vlans']), 3) for vlan in vlans['vlans']: assert_in(vlan['id'], vlans_ids) self.api_vlan.delete(vlans_ids) def test_insert_a_vlan_with_wrong_data(self): """ Tries to insert a vlan with wrong data """ vlan_data = { 'name': 'Vlan 33', 'environment': 3, 'fake_data': True, } with assert_raises(NetworkAPIClientError): self.api_vlan.create([vlan_data]) def test_delete_a_single_vlan(self): """ Tries to delete a single vlan """ vlan_data = { 'name': 'Vlan 15', 'environment': 1, } vlan_id = self.api_vlan.create([vlan_data])[0]['id'] self.api_vlan.delete([vlan_id]) with assert_raises(NetworkAPIClientError): vlan = self.api_vlan.get([vlan_id]) def test_delete_a_list_of_vlans(self): """ Tries to delete a list of vlans """ vlans_data = [{ 'name': 'Vlan 40', 'environment': 1, }, { 'name': 'Vlan 41', 'environment': 2, }, { 'name': 'Vlan 42', 'environment': 2, }] vlans_ids = [vlan['id'] for vlan in self.api_vlan.create(vlans_data)] self.api_vlan.delete(vlans_ids) with assert_raises(NetworkAPIClientError): self.api_vlan.get(vlans_ids) def test_delete_a_non_existent_vlan(self): """ Tries to delete a non existent vlan """ with assert_raises(NetworkAPIClientError): self.api_vlan.delete([44]) def test_update_a_vlan(self): """ Updates a single vlan """ vlan_data = { 'name': 'Vlan 38', 'environment': 1, } vlan_id = self.api_vlan.create([vlan_data])[0]['id'] vlan = self.api_vlan.get([vlan_id])['vlans'][0] new_name = vlan['name'] = 'Vlan 40' self.api_vlan.update([vlan]) vlan = self.api_vlan.get([vlan_id])['vlans'][0] assert_equal(vlan['name'], new_name) self.api_vlan.delete([vlan_id]) def test_update_a_non_existent_vlan(self): """ Tries to update a non existent vlan """ vlan = self.api_vlan.get([1])['vlans'][0] vlan['id'] = 55 with assert_raises(NetworkAPIClientError): self.api_vlan.update([vlan]) def test_create_vlan_with_unauthorized_number_for_environment(self): """ Do not allow create a vlan with unauthorized number """ vlan_data = { 'name': 'Vlan 38', 'environment': 3, } with assert_raises(NetworkAPIClientError): self.api_vlan.create([vlan_data])
class TestApiEnvironmentVip(TestCase): def setUp(self): self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER, NETWORKAPI_PWD) self.api_environment_vip = self.client.create_api_environment_vip() self.api_network_ipv4 = self.client.create_api_network_ipv4() self.api_network_ipv6 = self.client.create_api_network_ipv6() self.api_environment = self.client.create_api_environment() self.api_vlan = self.client.create_api_vlan() self.non_existent_env_vip_id = 1111 def tearDown(self): pass # get tests def test_get_an_environment_vip_by_id(self): """ Get an environment vip by id """ env = self.api_environment_vip.get([1]) assert_equal(env['environments_vip'][0]['id'], 1) def test_try_to_get_a_non_existent_environment_vip_by_id(self): """ Try to get a non existent environment vip by id """ with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([self.non_existent_env_vip_id]) # search tests def test_search_environment_vip_by_extends_search(self): """ Search expecting list with one environment vips """ finalidade_txt = 'Red' cliente_txt = 'Red' search_data = { 'extends_search': [{ 'finalidade_txt': finalidade_txt, 'cliente_txt': cliente_txt, }] } envs_vip = self.api_environment_vip.search(search=search_data) assert_equal(envs_vip['total'], 1) assert_equal(envs_vip['environments_vip'][0]['finalidade_txt'], finalidade_txt) assert_equal(envs_vip['environments_vip'][0]['cliente_txt'], cliente_txt) def test_search_a_list_of_environment_vips(self): """ Search expecting list with two environment vips """ search_data = { 'extends_search': [{ 'finalidade_txt': 'Blue', 'cliente_txt': 'Red', }, { 'finalidade_txt': 'Green', 'cliente_txt': 'Green', }] } envs_vip = self.api_environment_vip.search(search=search_data) assert_equal(envs_vip['total'], 2) for env in envs_vip['environments_vip']: assert_in(env['finalidade_txt'], ('Blue', 'Green')) assert_in(env['cliente_txt'], ('Red', 'Green')) def test_search_a_non_existent_environment_vip(self): """ Search expecting list with zero environment vips """ search_data = { 'extends_search': [{ 'finalidade_txt': 'Green', 'cliente_txt': 'Red', }] } envs = self.api_environment_vip.search(search=search_data) assert_equal(envs['total'], 0) # post tests def test_create_environment_vip(self): """ Try to create a new environment vip """ env_vip_data = { 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] env_vip = self.api_environment_vip.get([env_vip_id]) assert_equal(env_vip['environments_vip'][0]['id'], env_vip_id) self.api_environment_vip.delete([env_vip_id]) def test_create_many_environment_vips(self): """ Try to create many environment vips """ envs_vip_data = [{ 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', }, { 'finalidade_txt': 'Fin-2', 'cliente_txt': 'ClientTxt-2', 'ambiente_p44_txt': 'EnvP44Txt-2', 'description': 'Description-2', }] envs_vip_ids = self.api_environment_vip.create(envs_vip_data) envs_vip_ids = [e['id'] for e in envs_vip_ids] envs_vip = self.api_environment_vip.get(envs_vip_ids) assert_equal(len(envs_vip['environments_vip']), 2) for envs_vip in envs_vip['environments_vip']: assert_in(envs_vip['id'], envs_vip_ids) self.api_environment_vip.delete(envs_vip_ids) # put tests def test_update_environment_vip(self): """ Try to update an environment vip """ env_vip_data = { 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] env_vip = self.api_environment_vip.get([env_vip_id ])['environments_vip'][0] assert_equal(env_vip['id'], env_vip_id) new_finality_txt = env_vip['finalidade_txt'] = 'Fin-Updated' self.api_environment_vip.update([env_vip]) env_vip = self.api_environment_vip.get([env_vip_id ])['environments_vip'][0] assert_equal(env_vip['finalidade_txt'], new_finality_txt) self.api_environment_vip.delete([env_vip_id]) def test_update_a_non_existent_environment_vip(self): """ Try to update a non existent environment vip """ env_vip_data = { 'id': self.non_existent_env_vip_id, 'finalidade_txt': 'Green', 'cliente_txt': 'Red', 'description': 'Red', 'ambiente_p44_txt': 'Red', } with assert_raises(NetworkAPIClientError): self.api_environment_vip.update([env_vip_data]) # delete tests def test_delete_environment_vip(self): """ Test if we can delete an environment vip """ env_vip_data = { 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] assert_is_instance(self.api_environment_vip.get([env_vip_id]), dict) self.api_environment_vip.delete([env_vip_id]) with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id]) def test_delete_two_environments_vip(self): """ Test if we can delete two environment vips """ envs_vip_data = [{ 'finalidade_txt': 'Fin-1', 'cliente_txt': 'ClientTxt-1', 'ambiente_p44_txt': 'EnvP44Txt-1', 'description': 'Description-1', }, { 'finalidade_txt': 'Fin-2', 'cliente_txt': 'ClientTxt-2', 'ambiente_p44_txt': 'EnvP44Txt-2', 'description': 'Description-2', }] envs_vip_id = [ e['id'] for e in self.api_environment_vip.create(envs_vip_data) ] assert_is_instance(self.api_environment_vip.get(envs_vip_id), dict) self.api_environment_vip.delete(envs_vip_id) for env_vip_id in envs_vip_id: with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id]) def test_delete_a_non_existent_environment_vip(self): """ Try to delete a non existent environment vip """ with assert_raises(Exception): self.api_environment_vip.delete([self.non_existent_env_vip_id]) def test_try_delete_environment_vip_assoc_with_netipv4(self): """ Try to violate delete restriction on environment vip removal when env vip is associated with some network ipv4 """ with assert_raises(Exception): self.api_environment_vip.delete([13]) def test_try_delete_environment_vip_assoc_with_netipv6(self): """ Try to violate delete restriction on environment vip removal when env vip is associated with some network ipv6 """ with assert_raises(Exception): self.api_environment_vip.delete([13]) def test_try_delete_environment_vip_assoc_to_option_vip(self): """ Try to delete environment vip associated to some option vip """ env_vip_data = { 'finalidade_txt': 'Fin-Test', 'cliente_txt': 'ClientTxt-Test', 'ambiente_p44_txt': 'EnvP44Txt-Test', 'description': 'Description-Test', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] option_vip = self.client.create_option_vip()\ .add('tipo_opcao', 'nome_opcao_txt') self.client.create_option_vip()\ .associate(option_vip['option_vip']['id'], env_vip_id) self.api_environment_vip.delete([env_vip_id]) with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id]) def test_try_delete_environment_vip_assoc_to_env(self): """ Try to delete environment vip associated to some environment """ env_vip_data = { 'finalidade_txt': 'Fin-Test', 'cliente_txt': 'ClientTxt-Test', 'ambiente_p44_txt': 'EnvP44Txt-Test', 'description': 'Description-Test', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] env = 7 self.client.create_ambiente().associate(env, env_vip_id) self.api_environment_vip.delete([env_vip_id]) with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id]) def test_try_delete_environment_vip_assoc_to_options_vip_and_envs(self): """ Try to delete environment vip associated to some options vip and environments """ env_vip_data = { 'finalidade_txt': 'Fin-Test', 'cliente_txt': 'ClientTxt-Test', 'ambiente_p44_txt': 'EnvP44Txt-Test', 'description': 'Description-Test', } env_vip_id = self.api_environment_vip.create([env_vip_data])[0]['id'] options_vip = [1, 2] environments = [7, 8] for opt in options_vip: self.client.create_option_vip().associate(opt, env_vip_id) for env in environments: self.client.create_ambiente().associate(env, env_vip_id) self.api_environment_vip.delete([env_vip_id]) with assert_raises(NetworkAPIClientError): self.api_environment_vip.get([env_vip_id])
def get_clientFactory(self): '''Get clientFactory of NetworkAPI ''' user = self.get_user() return ClientFactory(NETWORK_API_URL, user.get_username(), user.get_password(), user.get_user_ldap())
def lost_pass(request): form = LoginForm() modal_auto_open = "true" form_pass = None try: if request.method == 'POST': form_pass = PassForm(request.POST) if form_pass.is_valid(): client = ClientFactory(NETWORK_API_URL, NETWORK_API_USERNAME, NETWORK_API_PASSWORD) users = client.create_usuario().listar() users = users.get("usuario") username = form_pass.cleaned_data['username'] email = form_pass.cleaned_data['email'] for user in users: if user.get("user").upper() == username.upper(): if user.get("email") == email: if not user.get('user_ldap'): pass_open = make_random_password() password = hashlib.md5(pass_open).hexdigest() ativo = '1' if user.get('ativo') else '0' client.create_usuario().alterar( user.get('id'), user.get('user'), password, user.get('nome'), ativo, user.get('email'), user.get('user_ldap')) lists = dict() lists['user'] = user.get('user') lists['new_pass'] = pass_open # Montar Email com nova senha connection = EmailBackend( username=EMAIL_HOST_USER, password=EMAIL_HOST_PASSWORD) send_email = EmailMessage( 'Solicitação de Nova Senha', loader.render_to_string( MAIL_NEW_PASS, lists), EMAIL_FROM, [email], connection=connection) send_email.content_subtype = "html" send_email.send() messages.add_message( request, messages.SUCCESS, auth_messages.get("email_success")) modal_auto_open = 'false' return render_to_response( templates.LOGIN, { 'form': form, 'form_pass': form_pass, 'modal': modal_auto_open }, context_instance=RequestContext(request)) else: messages.add_message( request, messages.ERROR, auth_messages.get( "user_ldap_cant_recover_pass")) modal_auto_open = 'false' return render_to_response( templates.LOGIN, { 'form': form, 'form_pass': form_pass, 'modal': modal_auto_open }, context_instance=RequestContext(request)) for user in users: if user.get("user_ldap") is not None and user.get( "user_ldap").upper() == username.upper(): messages.add_message( request, messages.ERROR, auth_messages.get("user_ldap_cant_recover_pass")) modal_auto_open = 'false' return render_to_response( templates.LOGIN, { 'form': form, 'form_pass': form_pass, 'modal': modal_auto_open }, context_instance=RequestContext(request)) messages.add_message(request, messages.ERROR, auth_messages.get("user_email_invalid")) modal_auto_open = 'false' except NetworkAPIClientError as e: logger.error(e) messages.add_message(request, messages.ERROR, e) modal_auto_open = 'false' except BaseException as e: logger.exception(e) logger.error("URLError Invalid EMAIL_HOST in settings.py") messages.add_message(request, messages.ERROR, "Invalid EMAIL_HOST in settings.py") modal_auto_open = 'false' return render_to_response(templates.LOGIN, { 'form': form, 'form_pass': form_pass, 'modal': modal_auto_open }, context_instance=RequestContext(request))
class NetworkAPI(object): logger = logging.getLogger(__name__) def __init__(self): self.client = ClientFactory( NETWORKAPI_ENDPOINT, NETWORKAPI_USER, NETWORKAPI_PASSWORD ) def _log_debug_request(self, func, param_id): self.logger.debug('[DriverNapi][request] %s %s' % (func, param_id)) def _log_debug_response(self, func, param_id, response): self.logger.debug('[DriverNapi][response] %s %s/n%s' % (func, param_id, response)) def _log_error_response(self, func, param_id, response): self.logger.error( '[DriverNapi][response] %s %s/n%s' % (func, param_id, response)) def get_pool(self, pool_id): """Return Pool""" try: response = self.client.create_api_pool().get( ids=[pool_id], kind='details') except NetworkAPIClientError as err: self._log_error_response('get_pool', pool_id, err) return [] else: self._log_debug_response('get_pool', pool_id, response) pools = response.get('server_pools') if pools: pools = pools[0] return pools def get_pool_by_member_id(self, member_id): """Return Pool by member id""" self._log_debug_request('get_pool_by_member_id', member_id) try: response = self.client.create_api_pool().search(search={ 'extends_search': [{ 'serverpoolmember': member_id }]}, kind='details') except NetworkAPIClientError as err: self._log_error_response('get_pool_by_member_id', member_id, err) return [] else: self._log_debug_response( 'get_pool_by_member_id', member_id, response) pools = response.get('server_pools') if pools: pools = pools[0] return pools def get_vip(self, vip_id): """Return VIP""" self._log_debug_request('get_vip', vip_id) try: response = self.client.create_api_vip_request().get( ids=[vip_id], kind='details') except NetworkAPIClientError as err: self._log_error_response('get_vip', vip_id, err) return [] else: self._log_debug_response('get_vip', vip_id, response) vips = response.get('vips') if vips: vips = vips[0] return vips def get_vip_by_portpool_id(self, portpool_id): """Return VIP by port pool id""" self._log_debug_request('get_vip_by_portpool_id', portpool_id) try: response = self.client.create_api_vip_request().search(search={ 'extends_search': [{ 'viprequestport__viprequestportpool': portpool_id }]}, kind='details') except NetworkAPIClientError as err: self._log_error_response( 'get_vip_by_portpool_id', portpool_id, err) return [] else: self._log_debug_response( 'get_vip_by_portpool_id', portpool_id, response) vips = response.get('vips') if vips: vips = vips[0] return vips def get_equipment(self, equipment_id): """Return Equipment""" self._log_debug_request('get_equipment', equipment_id) try: response = self.client.create_api_equipment().get( ids=[equipment_id], include=[ 'equipment_type__details', 'ipv4__basic__networkipv4', 'ipv6__basic__networkipv6']) except NetworkAPIClientError as err: self._log_error_response('get_equipment', equipment_id, err) return [] else: self._log_debug_response('get_equipment', equipment_id, response) equipments = response.get('equipments') if equipments: equipments = equipments[0] return equipments def get_network_ipv4_id(self, net_id): """Return NetworkIpv4""" self._log_debug_request('get_network_ipv4_id', net_id) try: response = self.client.create_api_network_ipv4().get( ids=[net_id], fields=['id', 'network_type__details', 'active', 'networkv4', 'vlan__basic']) except NetworkAPIClientError as err: self._log_error_response('get_network_ipv4_id', net_id, err) return [] else: self._log_debug_response('get_network_ipv4_id', net_id, response) networks = response.get('networks') if networks: networks = networks[0] return networks def get_network_ipv6_id(self, net_id): """Return NetworkIpv6""" self._log_debug_request('get_network_ipv4_id', net_id) try: response = self.client.create_api_network_ipv6().get( ids=[net_id], fields=['id', 'network_type__details', 'active', 'networkv6', 'vlan__basic']) except NetworkAPIClientError as err: self._log_error_response('get_network_ipv4_id', net_id, err) return [] else: self._log_debug_response('get_network_ipv4_id', net_id, response) networks = response.get('networks') if networks: networks = networks[0] return networks def get_ipv4_by_ip_equipment_id(self, ip_equipment_id): """Return Ipv4 by ip equipment id""" self._log_debug_request('get_ipv4_by_ip_equipment_id', ip_equipment_id) try: response = self.client.create_api_ipv4().search( search={'extends_search': [ {'ipequipamento': ip_equipment_id}]}, fields=['networkipv4', 'ip_formated'] ) except NetworkAPIClientError as err: self._log_error_response( 'get_ipv4_by_ip_equipment_id', ip_equipment_id, err) return [] else: self._log_debug_response( 'get_ipv4_by_ip_equipment_id', ip_equipment_id, response) ips = response.get('ips') if ips: ips = ips[0] return ips def get_ipv6_by_ip_equipment_id(self, ip_equipment_id): """Return Ipv6 by ip equipment id""" self._log_debug_request('get_ipv6_by_ip_equipment_id', ip_equipment_id) try: response = self.client.create_api_ipv6().search( search={'extends_search': [ {'ipv6equipament': ip_equipment_id}]}, fields=['networkipv6', 'ip_formated'] ) except NetworkAPIClientError as err: self._log_error_response( 'get_ipv6_by_ip_equipment_id', ip_equipment_id, err) return [] else: self._log_debug_response( 'get_ipv6_by_ip_equipment_id', ip_equipment_id, response) ips = response.get('ips') if ips: ips = ips[0] return ips def get_vlan(self, vlan_id): """Return Vlan""" self._log_debug_request('get_vlan', vlan_id) try: response = self.client.create_api_vlan().get( ids=[vlan_id], include=['environment__basic']) except NetworkAPIClientError as err: self._log_error_response('get_vlan', vlan_id, err) return [] else: self._log_debug_response('get_vlan', vlan_id, response) vlans = response.get('vlans') if vlans: vlans = vlans[0] return vlans def get_environment(self, environment_id): """Return Environment""" self._log_debug_request('get_environment', environment_id) try: response = self.client.create_api_environment().get( ids=[environment_id], include=['default_vrf__details', 'father_environment__basic'] ) except NetworkAPIClientError as err: self._log_error_response('get_environment', environment_id, err) return [] else: self._log_debug_response( 'get_environment', environment_id, response) environments = response.get('environments') if environments: environments = environments[0] return environments