def create_node(self,
node_type,
node_name,
first_name=None,
last_name=None):
contact_nh, created = self.nh_model.objects.get_or_create(
node_name=node_name,
node_type=node_type,
node_meta_type=nc.META_TYPES[0], # Physical
creator=self.user,
modifier=self.user,
)
if created:
try:
nc.create_node(nc.graphdb.manager, node_name,
contact_nh.node_meta_type, node_type.type,
contact_nh.handle_id)
except CypherError:
pass
contact_node = nc.get_node_model(nc.graphdb.manager,
contact_nh.handle_id)
if first_name:
contact_node.add_property('first_name', first_name)
if last_name:
contact_node.add_property('last_name', last_name)
return contact_nh, contact_node
def test_migration(self):
"""Run the test itself."""
NodeType = self.new_state.apps.get_model('noclook', 'NodeType')
NodeHandle = self.new_state.apps.get_model('noclook', 'NodeHandle')
contact_type, created = NodeType.objects.get_or_create(type='Contact',
slug='contact')
contact_nhs = NodeHandle.objects.filter(node_type=contact_type)
for nh in contact_nhs:
# get their node
contact_node = nc.get_node_model(nc.graphdb.manager, nh.handle_id)
# check that node_name and first_name are set
first_name = contact_node.data.get('first_name', None)
self.assertIsNotNone(nh.node_name)
self.assertIsNotNone(first_name)
def test_migration(self):
"""Run the test itself."""
NodeType = self.new_state.apps.get_model('noclook', 'NodeType')
NodeHandle = self.new_state.apps.get_model('noclook', 'NodeHandle')
# for all types tested
for host_type_str in host_types:
host_type = NodeType.objects.get(type=host_type_str)
host_nhs = NodeHandle.objects.filter(node_type=host_type)
# for all nhs with this type
for host_nh in host_nhs:
host_node = nc.get_node_model(nc.graphdb.manager,
host_nh.handle_id)
# try to get the old values, assert none
val = host_node.data.get('responsible_group', None)
self.assertIsNone(val)
val = host_node.data.get('support_group', None)
self.assertIsNone(val)
# check that is linked to a group
rels = host_node.incoming.get('Takes_responsibility')
self.assertIsNotNone(rels)
group_node = rels[0]['node']
self.assertIsNotNone(group_node)
# check group name match one of the dropodown's choices
group_name = group_node.data['name']
self.assertTrue(
NodeHandle.objects.filter(node_name=group_name).exists())
rels = host_node.incoming.get('Supports')
self.assertIsNotNone(rels)
group_node = rels[0]['node']
self.assertIsNotNone(group_node)
# check group name match one of the dropodown's choices
group_name = group_node.data['name']
self.assertTrue(
NodeHandle.objects.filter(node_name=group_name).exists())
def test_migration(self):
"""Run the test itself."""
NodeType = self.new_state.apps.get_model('noclook', 'NodeType')
NodeHandle = self.new_state.apps.get_model('noclook', 'NodeHandle')
# for all types tested
for host_type_str in host_types:
host_type = NodeType.objects.get(type=host_type_str)
host_nhs = NodeHandle.objects.filter(node_type=host_type)
# for all nhs with this type
for host_nh in host_nhs:
host_node = nc.get_node_model(nc.graphdb.manager,
host_nh.handle_id)
# try to get the old values, assert is not none
val = host_node.data.get('responsible_group', None)
self.assertIsNotNone(val)
val = host_node.data.get('support_group', None)
self.assertIsNotNone(val)
def prepare(self):
"""Create host entities and set random values on responsible/support
group"""
User = self.old_state.apps.get_model('auth', 'User')
NodeType = self.old_state.apps.get_model('noclook', 'NodeType')
NodeHandle = self.old_state.apps.get_model('noclook', 'NodeHandle')
Dropdown = self.old_state.apps.get_model('noclook', 'Dropdown')
Choice = self.old_state.apps.get_model('noclook', 'Choice')
# This is something that only makes sense for this test:
# When it's run the target migration is applied two times
# The first one when it loads the new postgredb
# The sencond one when on test runtime
# It seems like after the first one the groups NOC/DEV are deleted
# on the postgredb but not on neo4j, so at this point if the relational
# db is empty, we'll empty the node db aswell
if not NodeHandle.objects.all().exists():
with nc.graphdb.manager.session as s:
s.run(
"MATCH (a:Node) OPTIONAL MATCH (a)-[r]-(b) DELETE a, b, r")
username = '******'
passwd = User.objects.make_random_password(length=30)
user = None
try:
user = User.objects.get(username=username)
except:
user = User(username=username, password=passwd).save()
for host_type_str in host_types:
# get or create type
host_type, created = NodeType.objects.get_or_create(
type=host_type_str, slug=slugify(host_type_str))
# set old values
group_dropdwn = Dropdown.objects.get(name="responsible_groups")
choices = [
x.value for x in Choice.objects.filter(dropdown=group_dropdwn)
]
responsible_group_val = random.choice(choices)
support_group_val = random.choice(choices)
node_name = 'Test {}'.format(host_type_str)
# create nodehandle and node
host_nh, created = NodeHandle.objects.get_or_create(
node_name=node_name,
node_type=host_type,
node_meta_type=nc.META_TYPES[0], # Physical
creator=user,
modifier=user,
)
if created:
try:
nc.create_node(nc.graphdb.manager, node_name,
host_nh.node_meta_type, host_type.type,
host_nh.handle_id)
except CypherError:
pass
host_node = nc.get_node_model(nc.graphdb.manager,
host_nh.handle_id)
# add properties
host_node.add_property('responsible_group', responsible_group_val)
host_node.add_property('support_group', support_group_val)
def prepare(self):
"""Create host entities and set random values on responsible/support
group"""
User = self.old_state.apps.get_model('auth', 'User')
NodeType = self.old_state.apps.get_model('noclook', 'NodeType')
NodeHandle = self.old_state.apps.get_model('noclook', 'NodeHandle')
Dropdown = self.old_state.apps.get_model('noclook', 'Dropdown')
Choice = self.old_state.apps.get_model('noclook', 'Choice')
username = '******'
passwd = User.objects.make_random_password(length=30)
user = None
try:
user = User.objects.get(username=username)
except:
user = User(username=username, password=passwd).save()
group_type, created = NodeType.objects.get_or_create(type='Group',
slug='group')
groups_nhs = NodeHandle.objects.filter(node_type=group_type)
# create groups if they don't exist
if not groups_nhs:
groupdropdown = Dropdown.objects.get(name='responsible_groups')
choices = Choice.objects.filter(dropdown=groupdropdown)
for choice in choices:
node_name = choice.name
group_nh, created = NodeHandle.objects.get_or_create(
node_name=node_name,
node_type=group_type,
node_meta_type=nc.META_TYPES[1], # Logical
creator=user,
modifier=user,
)
if created:
try:
nc.create_node(nc.graphdb.manager, node_name,
group_nh.node_meta_type,
group_type.type, group_nh.handle_id)
except CypherError:
pass
groups_nhs = NodeHandle.objects.filter(node_type=group_type)
for host_type_str in host_types:
# get or create type
host_type, created = NodeType.objects.get_or_create(
type=host_type_str, slug=slugify(host_type_str))
responsible_group = random.choice(groups_nhs)
support_group = random.choice(groups_nhs)
node_name = 'Test {}'.format(host_type_str)
# create nodehandle and node
host_nh, created = NodeHandle.objects.get_or_create(
node_name=node_name,
node_type=host_type,
node_meta_type=nc.META_TYPES[0], # Physical
creator=user,
modifier=user,
)
try:
nc.create_node(nc.graphdb.manager, node_name,
host_nh.node_meta_type, host_type.type,
host_nh.handle_id)
except CypherError:
pass
host_node = nc.get_node_model(nc.graphdb.manager,
host_nh.handle_id)
# link groups
r_gnode = nc.get_node_model(nc.graphdb.manager,
responsible_group.handle_id)
r_gnode.set_takes_responsibility(host_nh.handle_id)
s_gnode = nc.get_node_model(nc.graphdb.manager,
support_group.handle_id)
s_gnode.set_supports(host_nh.handle_id)