def test_export_optical_node(self):
# Setup test data
site = helpers.create_unique_node_handle(self.user, "Test site",
"site", "Location")
optical_node = helpers.create_unique_node_handle(
self.user, "NI-TEST-ROADM", "optical-node", "Physical")
on_node = optical_node.get_node()
helpers.set_location(self.user, on_node, site.handle_id)
helpers.dict_update_node(
self.user, optical_node.handle_id, {
"operational_state": "In service",
"rack_units": "2",
"type": "ciena6500"
})
# start testing
resp = self.client.get(self.get_full_url(site) + "export")
self.assertEquals('application/json', resp['Content-Type'])
result = resp.json()
# verify data
self.assertEquals(1, len(result))
on_result = result[0]
self.assertEqual(
{
u'name': u'NI-TEST-ROADM',
u'node_type': u'Optical Node',
u'type': u'ciena6500',
u'rack_units': u'2',
u'children': [],
u'operational_state': u'In service'
}, on_result)
def edit_rack(request, handle_id):
# Get needed data from node
nh, rack = helpers.get_nh_node(handle_id)
parent = rack.get_parent()
located_in = rack.get_located_in()
located_in_categories = ['host', 'odf', 'optical-node', 'router']
if request.POST:
form = forms.EditRackForm(request.POST)
if form.is_valid():
# Generic node update
helpers.form_update_node(request.user, rack.handle_id, form)
# Rack specific updates
if form.cleaned_data['relationship_parent']:
parent_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_parent'])
helpers.set_has(request.user, parent_nh.get_node(), rack.handle_id)
if form.cleaned_data['relationship_located_in']:
equipment = NodeHandle.objects.get(pk=form.cleaned_data['relationship_located_in'])
helpers.set_location(request.user, equipment.get_node(), rack.handle_id)
if 'saveanddone' in request.POST:
return redirect(nh.get_absolute_url())
else:
return redirect('%sedit' % nh.get_absolute_url())
else:
form = forms.EditRackForm(rack.data)
return render(request, 'noclook/edit/edit_rack.html',
{'node_handle': nh, 'form': form, 'parent': parent, 'node': rack,
'located_in': located_in, 'parent_categories': 'site', 'located_in_categories': located_in_categories})
def create_node(self, item, parent_nh, user):
errors = []
slug = slugify(item['node_type']).replace("_", "-")
meta_type = META_TYPES.get(item['node_type'], 'Physical')
nh = None
if item['node_type'] in GENERIC_TYPES:
nh = helpers.get_generic_node_handle(user, item['name'], slug,
meta_type)
else:
try:
nh = helpers.create_unique_node_handle(user, item['name'],
slug, meta_type)
except UniqueNodeError:
# Should have been validated, but hey race conditions
errors.append(
u"Could not create a {} named '{}', since one already exist"
.format(item['node_type'], item['name']))
if nh:
helpers.dict_update_node(
user,
nh.handle_id,
item,
filtered_keys=['node_type', 'children', 'ports'])
if item['node_type'] in HAS_RELATION:
helpers.set_has(user, parent_nh.get_node(), nh.handle_id)
else:
helpers.set_location(user, nh.get_node(), parent_nh.handle_id)
for child in item.get('children', []):
cerrors = self.create_node(child, nh, user)
errors += cerrors
return errors
def new_optical_node(request, slug=None):
form = forms.OpticalNodeForm(request.POST or None)
bulk_ports = forms.BulkPortsForm(request.POST or None)
if request.POST and form.is_valid() and bulk_ports.is_valid():
try:
name = form.cleaned_data['name']
nh = helpers.create_unique_node_handle(request.user, name,
'optical-node', 'Physical')
helpers.form_update_node(request.user, nh.handle_id, form)
node = nh.get_node()
user = request.user
if form.cleaned_data['relationship_location']:
location = NodeHandle.objects.get(
pk=form.cleaned_data['relationship_location'])
helpers.set_location(user, node, location.handle_id)
# create ports if needed
if not bulk_ports.cleaned_data['no_ports']:
data = bulk_ports.cleaned_data
helpers.bulk_create_ports(nh.get_node(), request.user, **data)
return redirect(nh.get_absolute_url())
except UniqueNodeError:
form.add_error('name',
'An Optical Node with that name already exists.')
return render(request, 'noclook/create/create_optical_node.html', {
'form': form,
'bulk_ports': bulk_ports
})
def new_patch_panel(request, **kwargs):
if request.POST:
form = forms.NewPatchPannelForm(request.POST)
ports_form = forms.BulkPortsForm(request.POST)
if form.is_valid() and ports_form.is_valid():
nh = helpers.form_to_generic_node_handle(request, form,
'patch-panel', 'Physical')
helpers.form_update_node(request.user, nh.handle_id, form)
data = form.cleaned_data
node = nh.get_node()
if data['relationship_location']:
location = NodeHandle.objects.get(
pk=data['relationship_location'])
helpers.set_location(request.user, node, location.handle_id)
if not ports_form.cleaned_data['no_ports']:
data = ports_form.cleaned_data
helpers.bulk_create_ports(nh.get_node(), request.user, **data)
return redirect(nh.get_absolute_url())
else:
form = forms.NewPatchPannelForm()
ports_form = forms.BulkPortsForm({
'port_type': 'RJ45',
'offset': 1,
'num_ports': '0'
})
return render(request, 'noclook/create/create_patch_panel.html', {
'form': form,
'ports_form': ports_form
})
def new_host(request):
form = forms.NewHostForm(request.POST or None)
user = request.user
if request.POST:
if form.is_valid():
data = form.cleaned_data
if data['relationship_owner'] or data['relationship_location']:
meta_type = 'Physical'
else:
meta_type = 'Logical'
try:
nh = helpers.form_to_unique_node_handle(
request, form, 'host', meta_type)
except UniqueNodeError:
form.add_error('name', 'A Host with that name already exists.')
return render(request, 'noclook/create/create_host.html',
{'form': form})
helpers.form_update_node(user, nh.handle_id, form)
node = nh.get_node()
if data['relationship_owner']:
owner = NodeHandle.objects.get(pk=data['relationship_owner'])
helpers.set_owner(user, node, owner.handle_id)
if data['relationship_location']:
location = NodeHandle.objects.get(
pk=data['relationship_location'])
helpers.set_location(user, node, location.handle_id)
return redirect(nh.get_absolute_url())
return render(request, 'noclook/create/create_host.html', {'form': form})
def _handle_location(user, node, location_id):
if location_id:
location_nh = _nh_safe_get(location_id)
if location_nh:
# Remove old.
helpers.remove_locations(user, node)
# Set new location
helpers.set_location(user, node, location_nh.handle_id)
def test_decommissioned_equipment(self):
self.skipTest('Not working as expected yet.')
# Setup test data
site = helpers.create_unique_node_handle(self.user, "Test site",
"site", "Location")
site_node = site.get_node()
rack = helpers.get_generic_node_handle(self.user, "A.01", "rack",
"Location")
helpers.set_has(self.user, site_node, rack.handle_id)
odf = helpers.create_unique_node_handle(self.user, "NI-TEST-ODF-01",
"odf", "Physical")
odf_node = odf.get_node()
helpers.dict_update_node(self.user, odf.handle_id, {"max_ports": 24})
helpers.set_location(self.user, odf_node, rack.handle_id)
decom_on = helpers.create_unique_node_handle(self.user,
"NI-TEST-ON-01",
"optical-node",
"Physical")
decom_on_node = decom_on.get_node()
helpers.dict_update_node(self.user, decom_on.handle_id,
{"operational_state": "Decommissioned"})
helpers.set_location(self.user, decom_on_node, rack.handle_id)
helpers.create_port(decom_on_node, "1", self.user)
helpers.create_port(decom_on_node, "2", self.user)
# End test data
resp = self.client.get(self.get_full_url(site) + "export")
self.assertEquals('application/json', resp['Content-Type'])
result = resp.json()
# verify data
self.assertEquals(1, len(result))
rack_result = result[0]
self.assertDictContainsSubset({
'name': 'A.01',
'node_type': 'Rack'
}, rack_result)
rack_equip = rack_result['children']
# Decommissioned equipment should be gone
self.assertEquals(1, len(rack_equip))
self.assertDictContainsSubset(
{
'node_type': 'ODF',
'name': 'NI-TEST-ODF-01'
}, rack_equip[0])
self.assertEquals(2, len(rack_equip[0]['children']))
def new_external_equipment(request, **kwargs):
if request.POST:
form = forms.NewExternalEquipmentForm(request.POST)
if form.is_valid():
nh = helpers.form_to_generic_node_handle(request, form, 'external-equipment', 'Physical')
helpers.form_update_node(request.user, nh.handle_id, form)
data = form.cleaned_data
node = nh.get_node()
if data['relationship_location']:
location = NodeHandle.objects.get(pk=data['relationship_location'])
helpers.set_location(request.user, node, location.handle_id)
if data['relationship_owner']:
owner = NodeHandle.objects.get(pk=data['relationship_owner'])
helpers.set_owner(request.user, node, owner.handle_id)
return redirect(nh.get_absolute_url())
else:
form = forms.NewExternalEquipmentForm()
return render(request, 'noclook/create/create_external_equipment.html', {'form': form})
def setUp(self):
super(SearchTypeaheadPortsCase, self).setUp()
self.typeahead_url = "/search/typeahead/ports"
site = helpers.create_unique_node_handle(self.user, "UK-HEX", "site",
"Location")
rack = helpers.get_generic_node_handle(self.user, "A.01", "rack",
"Location")
helpers.set_has(self.user, site.get_node(), rack.handle_id)
odf1 = helpers.create_unique_node_handle(self.user, "test-odf1", "odf",
"Physical")
odf1_node = odf1.get_node()
helpers.set_location(self.user, odf1_node, rack.handle_id)
helpers.create_port(odf1_node, "1+2", self.user)
helpers.create_port(odf1_node, "3+4", self.user)
odf2 = helpers.create_unique_node_handle(self.user, "other-odf2",
"odf", "Physical")
odf2_node = odf2.get_node()
helpers.set_location(self.user, odf2_node, site.handle_id)
helpers.create_port(odf2_node, "11+12", self.user)
helpers.create_port(odf2_node, "13+14", self.user)
router = helpers.create_unique_node_handle(self.user,
"uk-hex.nordu.net",
"router", "Physical")
router_node = router.get_node()
helpers.set_location(self.user, router_node, site.handle_id)
helpers.create_port(router_node, "ge-0/0/1", self.user)
helpers.create_port(router_node, "ge-0/0/2", self.user)
helpers.create_port(router_node, "ge-0/1/1", self.user)
def add_location(self, user, physical_nh, location_nh):
helpers.set_location(user, physical_nh.get_node(),
location_nh.handle_id)
def link_located_in(cls, user, location_nh, physical_nh):
physical_node = physical_nh.get_node()
location_handle_id = location_nh.handle_id
helpers.set_location(user, physical_node, location_handle_id)
def test_populated_site(self):
# Setup test data
site = helpers.create_unique_node_handle(self.user, "Test site",
"site", "Location")
site_node = site.get_node()
rack = helpers.get_generic_node_handle(self.user, "A.01", "rack",
"Location")
helpers.set_has(self.user, site_node, rack.handle_id)
odf = helpers.create_unique_node_handle(self.user, "NI-TEST-ODF-01",
"odf", "Physical")
odf_node = odf.get_node()
helpers.dict_update_node(self.user, odf.handle_id, {"max_ports": 24})
helpers.set_location(self.user, odf_node, rack.handle_id)
helpers.create_port(odf_node, "1", self.user)
helpers.create_port(odf_node, "2", self.user)
helpers.create_port(odf_node, "3", self.user)
router = helpers.create_unique_node_handle(
self.user, "ni-test.routers.nordu.net", "router", "Physical")
router_node = router.get_node()
helpers.dict_update_node(self.user, router.handle_id, {
"operational_state": "Testing",
"rack_units": 2
})
helpers.set_location(self.user, router_node, rack.handle_id)
odf2 = helpers.get_generic_node_handle(self.user, "NI-TEST-ODF-02",
"odf", "Physical")
odf2_node = odf2.get_node()
helpers.set_location(self.user, odf2_node, site.handle_id)
# Done setting up testdata
resp = self.client.get(self.get_full_url(site) + "export")
self.assertEquals('application/json', resp['Content-Type'])
result = resp.json()
# verify data
self.assertEquals(2, len(result))
self.assertDictContainsSubset({
'name': 'A.01',
'node_type': 'Rack'
}, result[0])
self.assertDictContainsSubset(
{
'node_type': 'ODF',
'name': 'NI-TEST-ODF-02'
}, result[1])
# Check racked equipment
rack_equp = result[0]['children']
self.assertEquals(2, len(rack_equp))
odf1_result = rack_equp[0]
self.assertDictContainsSubset(
{
'node_type': 'ODF',
'name': 'NI-TEST-ODF-01',
'max_ports': 24
}, odf1_result)
# Check ODF ports
odf1_ports = odf1_result['children']
self.assertEquals(3, len(odf1_ports))
self.assertDictContainsSubset(
{
'node_type': 'Port',
'name': '1',
'port_type': ''
}, odf1_ports[0])
self.assertDictContainsSubset(
{
'node_type': 'Port',
'name': '2',
'description': ''
}, odf1_ports[1])
self.assertDictContainsSubset({
'node_type': 'Port',
'name': '3'
}, odf1_ports[2])
# Check router
router = rack_equp[1]
self.assertDictContainsSubset(
{
'node_type': 'Router',
'name': 'ni-test.routers.nordu.net'
}, router)
