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.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 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 setUp(self):
self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER,
NETWORKAPI_PWD)
self.api_net_ipv4 = self.client.create_api_network_ipv4()
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 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])
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 setUp(self):
self.client = ClientFactory(NETWORKAPI_URL, NETWORKAPI_USER,
NETWORKAPI_PWD)
self.api_vlan = self.client.create_api_vlan()
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))
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 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
