def test_replacement_1(self):
n1 = Node().store()
n2 = Node().store()
n1.set_extra("pippo", [1, 2, u'a'])
n1.set_extra("pippobis", [5, 6, u'c'])
n2.set_extra("pippo2", [3, 4, u'b'])
self.assertEqual(n1.get_extras(),
{'pippo': [1, 2, u'a'], 'pippobis': [5, 6, u'c'], '_aiida_hash': n1.get_hash()})
self.assertEquals(n2.get_extras(), {'pippo2': [3, 4, 'b'], '_aiida_hash': n2.get_hash()})
new_attrs = {"newval1": "v", "newval2": [1, {"c": "d", "e": 2}]}
n1.reset_extras(new_attrs)
self.assertEquals(n1.get_extras(), new_attrs)
self.assertEquals(n2.get_extras(), {'pippo2': [3, 4, 'b'], '_aiida_hash': n2.get_hash()})
n1.del_extra('newval2')
del new_attrs['newval2']
self.assertEquals(n1.get_extras(), new_attrs)
# Also check that other nodes were not damaged
self.assertEquals(n2.get_extras(), {'pippo2': [3, 4, 'b'], '_aiida_hash': n2.get_hash()})
def test_inputs_parents_relationship(self):
"""
This test checks that the inputs_q, parents_q relationship and the
corresponding properties work as expected.
"""
n1 = Node().store()
n2 = Node().store()
n3 = Node().store()
# Create a link between these 2 nodes
n2.add_link_from(n1, "N1")
n3.add_link_from(n2, "N2")
# Check that the result of outputs is a list
self.assertIsInstance(n1.dbnode.inputs, list,
"This is expected to be a list")
# Check that the result of outputs_q is a query
from sqlalchemy.orm.dynamic import AppenderQuery
self.assertIsInstance(n1.dbnode.inputs_q, AppenderQuery,
"This is expected to be an AppenderQuery")
# Check that the result of inputs is correct
out = set([_.pk for _ in n3.dbnode.inputs])
self.assertEqual(out, set([n2.pk]))
def test_replacement_1(self):
n1 = Node().store()
n2 = Node().store()
n1.dbnode.set_extra("pippo", [1, 2, 'a'])
n1.dbnode.set_extra("pippobis", [5, 6, 'c'])
n2.dbnode.set_extra("pippo2", [3, 4, 'b'])
self.assertEquals(n1.dbnode.extras, {
'pippo': [1, 2, 'a'],
'pippobis': [5, 6, 'c']
})
self.assertEquals(n2.dbnode.extras, {'pippo2': [3, 4, 'b']})
new_attrs = {"newval1": "v", "newval2": [1, {"c": "d", "e": 2}]}
# Old way of doing. With SqlAlchemy, just set the dictionnary to a new
# one and you're done
# DbExtra.reset_values_for_node(n1.dbnode, attributes=new_attrs)
n1.dbnode.extras = new_attrs
self.assertEquals(n1.dbnode.extras, new_attrs)
self.assertEquals(n2.dbnode.extras, {'pippo2': [3, 4, 'b']})
n1.dbnode.del_extra('newval2')
self.assertEquals(n1.dbnode.extras, new_attrs)
# Also check that other nodes were not damaged
self.assertEquals(n2.dbnode.extras, {'pippo2': [3, 4, 'b']})
def test_get_inputs_and_outputs(self):
a1 = Node().store()
a2 = Node().store()
a3 = Node().store()
a4 = Node().store()
a2.add_link_from(a1)
a3.add_link_from(a2)
a4.add_link_from(a2)
a4.add_link_from(a3)
# I check that I get the correct links
self.assertEquals(set([n.uuid for n in a1.get_inputs()]), set([]))
self.assertEquals(set([n.uuid for n in a1.get_outputs()]),
set([a2.uuid]))
self.assertEquals(set([n.uuid for n in a2.get_inputs()]),
set([a1.uuid]))
self.assertEquals(set([n.uuid for n in a2.get_outputs()]),
set([a3.uuid, a4.uuid]))
self.assertEquals(set([n.uuid for n in a3.get_inputs()]),
set([a2.uuid]))
self.assertEquals(set([n.uuid for n in a3.get_outputs()]),
set([a4.uuid]))
self.assertEquals(set([n.uuid for n in a4.get_inputs()]),
set([a2.uuid, a3.uuid]))
self.assertEquals(set([n.uuid for n in a4.get_outputs()]), set([]))
def test_replacement_1(self):
from aiida.backends.djsite.db.models import DbExtra
n1 = Node().store()
n2 = Node().store()
DbExtra.set_value_for_node(n1._dbnode, "pippo", [1, 2, 'a'])
DbExtra.set_value_for_node(n1._dbnode, "pippobis", [5, 6, 'c'])
DbExtra.set_value_for_node(n2._dbnode, "pippo2", [3, 4, 'b'])
self.assertEquals(n1.get_extras(), {'pippo': [1, 2, 'a'],
'pippobis': [5, 6, 'c'],
'_aiida_hash': n1.get_hash()
})
self.assertEquals(n2.get_extras(), {'pippo2': [3, 4, 'b'],
'_aiida_hash': n2.get_hash()
})
new_attrs = {"newval1": "v", "newval2": [1, {"c": "d", "e": 2}]}
DbExtra.reset_values_for_node(n1._dbnode, attributes=new_attrs)
self.assertEquals(n1.get_extras(), new_attrs)
self.assertEquals(n2.get_extras(), {'pippo2': [3, 4, 'b'], '_aiida_hash': n2.get_hash()})
DbExtra.del_value_for_node(n1._dbnode, key='newval2')
del new_attrs['newval2']
self.assertEquals(n1.get_extras(), new_attrs)
# Also check that other nodes were not damaged
self.assertEquals(n2.get_extras(), {'pippo2': [3, 4, 'b'], '_aiida_hash': n2.get_hash()})
def fill_repo(self):
from aiida.orm import JobCalculation, CalculationFactory, Data, DataFactory
extra_name = self.__class__.__name__ + "/test_with_subclasses"
calc_params = {
'computer': self.computer,
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}
}
TemplateReplacerCalc = CalculationFactory(
'simpleplugins.templatereplacer')
ParameterData = DataFactory('parameter')
a1 = JobCalculation(**calc_params).store()
# To query only these nodes later
a1.set_extra(extra_name, True)
a2 = TemplateReplacerCalc(**calc_params).store()
# To query only these nodes later
a2.set_extra(extra_name, True)
a3 = Data().store()
a3.set_extra(extra_name, True)
a4 = ParameterData(dict={'a': 'b'}).store()
a4.set_extra(extra_name, True)
a5 = Node().store()
a5.set_extra(extra_name, True)
# I don't set the extras, just to be sure that the filtering works
# The filtering is needed because other tests will put stuff int he DB
a6 = JobCalculation(**calc_params)
a6.store()
a7 = Node()
a7.store()
def test_attr_with_reload(self):
a = Node()
a._set_attr('none', None)
a._set_attr('bool', self.boolval)
a._set_attr('integer', self.intval)
a._set_attr('float', self.floatval)
a._set_attr('string', self.stringval)
a._set_attr('dict', self.dictval)
a._set_attr('list', self.listval)
a.store()
b = Node.get_subclass_from_uuid(a.uuid)
self.assertIsNone(a.get_attr('none'))
self.assertEquals(self.boolval, b.get_attr('bool'))
self.assertEquals(self.intval, b.get_attr('integer'))
self.assertEquals(self.floatval, b.get_attr('float'))
self.assertEquals(self.stringval, b.get_attr('string'))
self.assertEquals(self.dictval, b.get_attr('dict'))
self.assertEquals(self.listval, b.get_attr('list'))
# Reload directly
b = Node(dbnode=a.dbnode)
self.assertIsNone(a.get_attr('none'))
self.assertEquals(self.boolval, b.get_attr('bool'))
self.assertEquals(self.intval, b.get_attr('integer'))
self.assertEquals(self.floatval, b.get_attr('float'))
self.assertEquals(self.stringval, b.get_attr('string'))
self.assertEquals(self.dictval, b.get_attr('dict'))
self.assertEquals(self.listval, b.get_attr('list'))
with self.assertRaises(ModificationNotAllowed):
a._set_attr('i', 12)
def test_query(self):
"""
Test if queries are working
"""
g1 = Group(name='testquery1').store()
g2 = Group(name='testquery2').store()
n1 = Node().store()
n2 = Node().store()
n3 = Node().store()
n4 = Node().store()
g1.add_nodes([n1, n2])
g2.add_nodes([n1, n3])
newuser = DbUser(email='*****@*****.**', password='').save()
g3 = Group(name='testquery3', user=newuser).store()
# I should find it
g1copy = Group.get(uuid=g1.uuid)
self.assertEquals(g1.pk, g1copy.pk)
# Try queries
res = Group.query(nodes=n4)
self.assertEquals([_.pk for _ in res], [])
res = Group.query(nodes=n1)
self.assertEquals([_.pk for _ in res], [_.pk for _ in [g1, g2]])
res = Group.query(nodes=n2)
self.assertEquals([_.pk for _ in res], [_.pk for _ in [g1]])
# I try to use 'get' with zero or multiple results
with self.assertRaises(NotExistent):
Group.get(nodes=n4)
with self.assertRaises(MultipleObjectsError):
Group.get(nodes=n1)
self.assertEquals(Group.get(nodes=n2).pk, g1.pk)
# Query by user
res = Group.query(user=newuser)
self.assertEquals(set(_.pk for _ in res), set(_.pk for _ in [g3]))
# Same query, but using a string (the username=email) instead of
# a DbUser object
res = Group.query(user=newuser.email)
self.assertEquals(set(_.pk for _ in res), set(_.pk for _ in [g3]))
res = Group.query(user=get_automatic_user())
self.assertEquals(set(_.pk for _ in res), set(_.pk for _ in [g1, g2]))
# Final cleanup
g1.delete()
g2.delete()
newuser.delete()
def test_with_subclasses(self, computer):
extra_name = self.__class__.__name__ + "/test_with_subclasses"
calc_params = {
'computer': computer,
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}
}
TemplateReplacerCalc = CalculationFactory(
'simpleplugins.templatereplacer')
ParameterData = DataFactory('parameter')
a1 = JobCalculation(**calc_params).store()
# To query only these nodes later
a1.set_extra(extra_name, True)
a2 = TemplateReplacerCalc(**calc_params).store()
# To query only these nodes later
a2.set_extra(extra_name, True)
a3 = Data().store()
a3.set_extra(extra_name, True)
a4 = ParameterData(dict={'a': 'b'}).store()
a4.set_extra(extra_name, True)
a5 = Node().store()
a5.set_extra(extra_name, True)
# I don't set the extras, just to be sure that the filtering works
# The filtering is needed because other tests will put stuff int he DB
a6 = JobCalculation(**calc_params)
a6.store()
a7 = Node()
a7.store()
# Query by calculation
results = list(JobCalculation.query(dbextras__key=extra_name))
# a3, a4, a5 should not be found because they are not JobCalculations.
# a6, a7 should not be found because they have not the attribute set.
self.assertEquals(set([i.pk for i in results]), set([a1.pk, a2.pk]))
# Same query, but by the generic Node class
results = list(Node.query(dbextras__key=extra_name))
self.assertEquals(set([i.pk for i in results]),
set([a1.pk, a2.pk, a3.pk, a4.pk, a5.pk]))
# Same query, but by the Data class
results = list(Data.query(dbextras__key=extra_name))
self.assertEquals(set([i.pk for i in results]), set([a3.pk, a4.pk]))
# Same query, but by the ParameterData subclass
results = list(ParameterData.query(dbextras__key=extra_name))
self.assertEquals(set([i.pk for i in results]), set([a4.pk]))
# Same query, but by the TemplateReplacerCalc subclass
results = list(TemplateReplacerCalc.query(dbextras__key=extra_name))
self.assertEquals(set([i.pk for i in results]), set([a2.pk]))
def test_query(self):
"""
Test if queries are working
"""
from aiida.orm.group import Group
from aiida.common.exceptions import NotExistent, MultipleObjectsError
g1 = Group(name='testquery1').store()
self.addCleanup(g1.delete)
g2 = Group(name='testquery2').store()
self.addCleanup(g2.delete)
n1 = Node().store()
n2 = Node().store()
n3 = Node().store()
n4 = Node().store()
g1.add_nodes([n1, n2])
g2.add_nodes([n1, n3])
newuser = self.backend.users.create(email='*****@*****.**')
g3 = Group(name='testquery3', user=newuser).store()
# I should find it
g1copy = Group.get(uuid=g1.uuid)
self.assertEquals(g1.pk, g1copy.pk)
# Try queries
res = Group.query(nodes=n4)
self.assertEquals([_.pk for _ in res], [])
res = Group.query(nodes=n1)
self.assertEquals([_.pk for _ in res], [_.pk for _ in [g1, g2]])
res = Group.query(nodes=n2)
self.assertEquals([_.pk for _ in res], [_.pk for _ in [g1]])
# I try to use 'get' with zero or multiple results
with self.assertRaises(NotExistent):
Group.get(nodes=n4)
with self.assertRaises(MultipleObjectsError):
Group.get(nodes=n1)
self.assertEquals(Group.get(nodes=n2).pk, g1.pk)
# Query by user
res = Group.query(user=newuser)
self.assertEquals(set(_.pk for _ in res), set(_.pk for _ in [g3]))
# Same query, but using a string (the username=email) instead of
# a DbUser object
res = Group.query(user=newuser.email)
self.assertEquals(set(_.pk for _ in res), set(_.pk for _ in [g3]))
res = Group.query(user=self.backend.users.get_automatic_user())
self.assertEquals(set(_.pk for _ in res), set(_.pk for _ in [g1, g2]))
def test_remove_nodes(self):
"""
Test node removal
"""
from aiida.orm.group import Group
n1 = Node().store()
n2 = Node().store()
n3 = Node().store()
n4 = Node().store()
n5 = Node().store()
n6 = Node().store()
n7 = Node().store()
n8 = Node().store()
n_out = Node().store()
g = Group(name='test_remove_nodes').store()
# Add initial nodes
g.add_nodes([n1, n2, n3, n4, n5, n6, n7, n8])
# Check
self.assertEquals(
set([_.pk for _ in [n1, n2, n3, n4, n5, n6, n7, n8]]),
set([_.pk for _ in g.nodes]))
# Remove a node that is not in the group: nothing should happen
# (same behavior of Django)
g.remove_nodes(n_out)
# Re-check
self.assertEquals(
set([_.pk for _ in [n1, n2, n3, n4, n5, n6, n7, n8]]),
set([_.pk for _ in g.nodes]))
# Remove one Node and check
g.remove_nodes(n4)
self.assertEquals(set([_.pk for _ in [n1, n2, n3, n5, n6, n7, n8]]),
set([_.pk for _ in g.nodes]))
# Remove one DbNode and check
g.remove_nodes(n7.dbnode)
self.assertEquals(set([_.pk for _ in [n1, n2, n3, n5, n6, n8]]),
set([_.pk for _ in g.nodes]))
# Remove a list of Nodes and check
g.remove_nodes([n1, n8])
self.assertEquals(set([_.pk for _ in [n2, n3, n5, n6]]),
set([_.pk for _ in g.nodes]))
# Remove a list of Nodes and check
g.remove_nodes([n1, n8])
self.assertEquals(set([_.pk for _ in [n2, n3, n5, n6]]),
set([_.pk for _ in g.nodes]))
# Remove a list of DbNodes and check
g.remove_nodes([n2.dbnode, n5.dbnode])
self.assertEquals(set([_.pk for _ in [n3, n6]]),
set([_.pk for _ in g.nodes]))
# Remove a mixed list of Nodes and DbNodes and check
g.remove_nodes([n3, n6.dbnode])
self.assertEquals(set(), set([_.pk for _ in g.nodes]))
# Cleanup
g.delete()
def test_attr_and_extras_multikey(self):
"""
Multiple nodes with the same key. This should not be a problem
I test only extras because the two tables are formally identical
"""
n1 = Node().store()
n2 = Node().store()
n1.set_extra('samename', 1)
# No problem, they are two different nodes
n2.set_extra('samename', 1)
def test_loop_not_allowed(self):
"""
Test that no loop can be formed when inserting link
"""
n1 = Node().store()
n2 = Node().store()
n3 = Node().store()
n4 = Node().store()
n2.add_link_from(n1)
n3.add_link_from(n2)
n4.add_link_from(n3)
with self.assertRaises(ValueError): # This would generate a loop
n1.add_link_from(n4)
def test_very_deep_attributes(self):
"""
Test attributes where the total length of the key, including the
separators, would be longer than the field length in the DB.
"""
from aiida.backends.djsite.db import models
n = Node()
semi_long_string = "abcdefghijklmnopqrstuvwxyz"
value = "some value"
attribute = {semi_long_string: value}
key_len = len(semi_long_string)
max_len = models.DbAttribute._meta.get_field_by_name(
'key')[0].max_length
while key_len < 2 * max_len:
# Create a deep, recursive attribute
attribute = {semi_long_string: attribute}
key_len += len(semi_long_string) + len(models.DbAttribute._sep)
n._set_attr(semi_long_string, attribute)
n.store()
all_keys = models.DbAttribute.objects.filter(
dbnode=n.dbnode).values_list('key', flat=True)
print max(len(i) for i in all_keys)
def test_delete_extras(self):
"""
Checks the ability of deleting extras, also when they are dictionaries
or lists.
"""
a = Node().store()
extras_to_set = {
'bool': self.boolval,
'integer': self.intval,
'float': self.floatval,
'string': self.stringval,
'dict': self.dictval,
'list': self.listval,
'further': 267,
}
for k, v in extras_to_set.iteritems():
a.set_extra(k, v)
self.assertEquals({k: v for k, v in a.iterextras()}, extras_to_set)
# I pregenerate it, it cannot change during iteration
list_keys = list(extras_to_set.keys())
for k in list_keys:
# I delete one by one the keys and check if the operation is
# performed correctly
a.del_extra(k)
del extras_to_set[k]
self.assertEquals({k: v for k, v in a.iterextras()}, extras_to_set)
def test_delete(self):
from aiida.orm.group import Group
from aiida.common.exceptions import NotExistent
n = Node().store()
g = Group(name='testgroup3', description='some other desc')
g.store()
gcopy = Group.get(name='testgroup3')
self.assertEquals(g.uuid, gcopy.uuid)
g.add_nodes(n)
self.assertEquals(len(g.nodes), 1)
g.delete()
with self.assertRaises(NotExistent):
# The group does not exist anymore
Group.get(name='testgroup3')
# I should be able to restore it
g.store()
# Now, however, by deleting and recreating it, I lost the elements
self.assertEquals(len(g.nodes), 0)
self.assertEquals(g.name, 'testgroup3')
self.assertEquals(g.description, 'some other desc')
self.assertTrue(g.is_user_defined)
# To avoid to find it in further tests
g.delete()
def test_comments(self):
# This is the best way to compare dates with the stored ones, instead of
# directly loading datetime.datetime.now(), or you can get a
# "can't compare offset-naive and offset-aware datetimes" error
user = get_automatic_user()
a = Node()
with self.assertRaises(ModificationNotAllowed):
a.add_comment('text', user=user)
self.assertEquals(a.get_comments(), [])
a.store()
before = timezone.now()
time.sleep(1) # I wait 1 second because MySql time precision is 1 sec
a.add_comment('text', user=user)
a.add_comment('text2', user=user)
time.sleep(1)
after = timezone.now()
comments = a.get_comments()
times = [i['mtime'] for i in comments]
for t in times:
self.assertTrue(t > before)
self.assertTrue(t < after)
self.assertEquals([(i['user__email'], i['content']) for i in comments],
[
(user.email, 'text'),
(user.email, 'text2'),
])
def test_attr_after_storing(self):
a = Node()
a._set_attr('none', None)
a._set_attr('bool', self.boolval)
a._set_attr('integer', self.intval)
a._set_attr('float', self.floatval)
a._set_attr('string', self.stringval)
a._set_attr('dict', self.dictval)
a._set_attr('list', self.listval)
a.store()
# Now I check if I can retrieve them, before the storage
self.assertIsNone(a.get_attr('none'))
self.assertEquals(self.boolval, a.get_attr('bool'))
self.assertEquals(self.intval, a.get_attr('integer'))
self.assertEquals(self.floatval, a.get_attr('float'))
self.assertEquals(self.stringval, a.get_attr('string'))
self.assertEquals(self.dictval, a.get_attr('dict'))
self.assertEquals(self.listval, a.get_attr('list'))
# And now I try to edit/delete the keys; I should not be able to do it
# after saving. I try only for a couple of attributes
with self.assertRaises(ModificationNotAllowed):
a._del_attr('bool')
with self.assertRaises(ModificationNotAllowed):
a._set_attr('integer', 13)
def test_load_nodes(self):
"""
Test for load_node() function.
"""
from aiida.orm import load_node
from aiida.common.exceptions import NotExistent
import aiida.backends.sqlalchemy
from aiida.backends.sqlalchemy import get_scoped_session
a = Node()
a.store()
self.assertEquals(a.pk, load_node(node_id=a.pk).pk)
self.assertEquals(a.pk, load_node(node_id=a.uuid).pk)
self.assertEquals(a.pk, load_node(pk=a.pk).pk)
self.assertEquals(a.pk, load_node(uuid=a.uuid).pk)
session = get_scoped_session()
try:
session.begin_nested()
with self.assertRaises(ValueError):
load_node(node_id=a.pk, pk=a.pk)
finally:
session.rollback()
try:
session.begin_nested()
with self.assertRaises(ValueError):
load_node(pk=a.pk, uuid=a.uuid)
finally:
session.rollback()
try:
session.begin_nested()
with self.assertRaises(ValueError):
load_node(pk=a.uuid)
finally:
session.rollback()
try:
session.begin_nested()
with self.assertRaises(ValueError):
load_node(uuid=a.pk)
finally:
session.rollback()
try:
session.begin_nested()
with self.assertRaises(ValueError):
load_node()
finally:
session.rollback()
def test_replace_extras(self):
"""
Checks the ability of replacing extras, removing the subkeys also when
these are dictionaries or lists.
"""
a = Node().store()
extras_to_set = {
'bool': True,
'integer': 12,
'float': 26.2,
'string': "a string",
'dict': {
"a": "b",
"sublist": [1, 2, 3],
"subdict": {
"c": "d"
}
},
'list': [1, True, "ggg", {
'h': 'j'
}, [9, 8, 7]],
}
# I redefine the keys with more complicated data, and
# changing the data type too
new_extras = {
'bool': 12,
'integer': [2, [3], 'a'],
'float': {
'n': 'm',
'x': [1, 'r', {}]
},
'string': True,
'dict': 'text',
'list': 66.3,
}
for k, v in extras_to_set.iteritems():
a.set_extra(k, v)
self.assertEquals({k: v for k, v in a.iterextras()}, extras_to_set)
for k, v in new_extras.iteritems():
# I delete one by one the keys and check if the operation is
# performed correctly
a.set_extra(k, v)
# I update extras_to_set with the new entries, and do the comparison
# again
extras_to_set.update(new_extras)
self.assertEquals({k: v for k, v in a.iterextras()}, extras_to_set)
def test_replace_extras_2(self):
"""
This is a Django specific test which checks (manually) that,
when replacing list and dict with objects that have no deepness,
no junk is left in the DB (i.e., no 'dict.a', 'list.3.h', ...
"""
from aiida.backends.djsite.db.models import DbExtra
a = Node().store()
extras_to_set = {
'bool': True,
'integer': 12,
'float': 26.2,
'string': "a string",
'dict': {"a": "b",
"sublist": [1, 2, 3],
"subdict": {
"c": "d"}},
'list': [1, True, "ggg", {'h': 'j'}, [9, 8, 7]],
}
# I redefine the keys with more complicated data, and
# changing the data type too
new_extras = {
'bool': 12,
'integer': [2, [3], 'a'],
'float': {'n': 'm', 'x': [1, 'r', {}]},
'string': True,
'dict': 'text',
'list': 66.3,
}
for k, v in extras_to_set.iteritems():
a.set_extra(k, v)
for k, v in new_extras.iteritems():
# I delete one by one the keys and check if the operation is
# performed correctly
a.set_extra(k, v)
# I update extras_to_set with the new entries, and do the comparison
# again
extras_to_set.update(new_extras)
# Check (manually) that, when replacing list and dict with objects
# that have no deepness, no junk is left in the DB (i.e., no
# 'dict.a', 'list.3.h', ...
self.assertEquals(len(DbExtra.objects.filter(
dbnode=a, key__startswith=('list' + DbExtra._sep))), 0)
self.assertEquals(len(DbExtra.objects.filter(
dbnode=a, key__startswith=('dict' + DbExtra._sep))), 0)
def test_creation(self):
from aiida.orm.group import Group
n = Node()
stored_n = Node().store()
with self.assertRaises(ValueError):
# No name specified
g = Group()
g = Group(name='testgroup')
with self.assertRaises(ValueError):
# Too many parameters
g = Group(name='testgroup', not_existing_kwarg=True)
with self.assertRaises(ModificationNotAllowed):
# g unstored
g.add_nodes(n)
with self.assertRaises(ModificationNotAllowed):
# g unstored
g.add_nodes(stored_n)
g.store()
with self.assertRaises(ValueError):
# n unstored
g.add_nodes(n)
g.add_nodes(stored_n)
nodes = list(g.nodes)
self.assertEquals(len(nodes), 1)
self.assertEquals(nodes[0].pk, stored_n.pk)
# To avoid to find it in further tests
g.delete()
def test_attr_before_storing(self):
a = Node()
a._set_attr('k1', self.boolval)
a._set_attr('k2', self.intval)
a._set_attr('k3', self.floatval)
a._set_attr('k4', self.stringval)
a._set_attr('k5', self.dictval)
a._set_attr('k6', self.listval)
a._set_attr('k7', self.emptydict)
a._set_attr('k8', self.emptylist)
a._set_attr('k9', None)
# Now I check if I can retrieve them, before the storage
self.assertEquals(self.boolval, a.get_attr('k1'))
self.assertEquals(self.intval, a.get_attr('k2'))
self.assertEquals(self.floatval, a.get_attr('k3'))
self.assertEquals(self.stringval, a.get_attr('k4'))
self.assertEquals(self.dictval, a.get_attr('k5'))
self.assertEquals(self.listval, a.get_attr('k6'))
self.assertEquals(self.emptydict, a.get_attr('k7'))
self.assertEquals(self.emptylist, a.get_attr('k8'))
self.assertIsNone(a.get_attr('k9'))
# And now I try to delete the keys
a._del_attr('k1')
a._del_attr('k2')
a._del_attr('k3')
a._del_attr('k4')
a._del_attr('k5')
a._del_attr('k6')
a._del_attr('k7')
a._del_attr('k8')
a._del_attr('k9')
with self.assertRaises(AttributeError):
# I delete twice the same attribute
a._del_attr('k1')
with self.assertRaises(AttributeError):
# I delete a non-existing attribute
a._del_attr('nonexisting')
with self.assertRaises(AttributeError):
# I get a deleted attribute
a.get_attr('k1')
with self.assertRaises(AttributeError):
# I get a non-existing attribute
a.get_attr('nonexisting')
def test_attrs_and_extras_wrong_keyname(self):
"""
Attribute keys cannot include the separator symbol in the key
"""
separator = DbAttributeBaseClass._sep
a = Node()
with self.assertRaises(ValidationError):
# I did not store, I cannot modify
a._set_attr('name' + separator, 'blablabla')
with self.assertRaises(ValidationError):
# I did not store, I cannot modify
a.set_extra('bool' + separator, 'blablabla')
def test_session_wfdata(self):
"""
This test checks that the
aiida.backends.sqlalchemy.models.workflow.DbWorkflowData#set_value
method works as expected. There were problems with the DbNode object
that was added as a value to a DbWorkflowData object. If there was
an older version of the dbnode in the session than the one given to
to the DbWorkflowData#set_value then there was a collision in the
session and SQLA identity map.
"""
from aiida.orm.node import Node
from aiida.workflows.test import WFTestSimpleWithSubWF
from aiida.backends.sqlalchemy import get_scoped_session
from aiida.orm.utils import load_node
# Create a node and store it
n = Node()
n.store()
# Keep some useful information
n_id = n.id
old_dbnode = n._dbnode
# Get the session
sess = get_scoped_session()
# Remove everything from the session
sess.expunge_all()
# Create a workflow and store it
wf = WFTestSimpleWithSubWF()
wf.store()
# Load a new version of the node
n_reloaded = load_node(n_id)
# Remove everything from the session
sess.expunge_all()
# Add the dbnode that was originally added to the session
sess.add(old_dbnode)
# Add as attribute the node that was added after the first cleanup
# of the session
# At this point the following command should not fail
wf.add_attribute('a', n_reloaded)
def test_attrs_and_extras_wrong_keyname(self):
"""
Attribute keys cannot include the separator symbol in the key
"""
from aiida.backends.djsite.db.models import DbAttributeBaseClass
from aiida.common.exceptions import ValidationError
separator = DbAttributeBaseClass._sep
a = Node()
with self.assertRaises(ValidationError):
# I did not store, I cannot modify
a._set_attr('name' + separator, 'blablabla')
with self.assertRaises(ValidationError):
# I did not store, I cannot modify
a.set_extra('bool' + separator, 'blablabla')
def test_add_nodes(self):
"""
Test different ways of adding nodes
"""
from aiida.orm.group import Group
n1 = Node().store()
n2 = Node().store()
n3 = Node().store()
n4 = Node().store()
n5 = Node().store()
n6 = Node().store()
n7 = Node().store()
n8 = Node().store()
g = Group(name='test_adding_nodes')
g.store()
# Single node
g.add_nodes(n1)
# List of nodes
g.add_nodes([n2, n3])
# Single DbNode
g.add_nodes(n4.dbnode)
# List of DbNodes
g.add_nodes([n5.dbnode, n6.dbnode])
# List of Nodes and DbNodes
g.add_nodes([n7, n8.dbnode])
# Check
self.assertEquals(
set([_.pk for _ in [n1, n2, n3, n4, n5, n6, n7, n8]]),
set([_.pk for _ in g.nodes]))
# Try to add a node that is already present: there should be no problem
g.add_nodes(n1)
self.assertEquals(
set([_.pk for _ in [n1, n2, n3, n4, n5, n6, n7, n8]]),
set([_.pk for _ in g.nodes]))
# Cleanup
g.delete()
def start(self):
from aiida.orm.node import Node
# Testing parameters
p = self.get_parameters()
# Testing calculations
self.attach_calculation(self.generate_calc())
self.attach_calculation(self.generate_calc())
# Testing report
self.append_to_report("Starting workflow with params: {0}".format(p))
# Testing attachments
n = Node().store()
attrs = {"a": [1, 2, 3], "n": n}
self.add_attributes(attrs)
# Test process
self.next(self.second_step)
def test_load_nodes(self):
"""
"""
from aiida.orm import load_node
from aiida.common.exceptions import NotExistent, InputValidationError
a = Node()
a.store()
self.assertEquals(a.pk, load_node(pk=a.pk).pk)
self.assertEquals(a.pk, load_node(uuid=a.uuid).pk)
with self.assertRaises(InputValidationError):
load_node(node_id=a.pk, pk=a.pk)
with self.assertRaises(InputValidationError):
load_node(pk=a.pk, uuid=a.uuid)
with self.assertRaises(TypeError):
load_node(pk=a.uuid)
with self.assertRaises(TypeError):
load_node(uuid=a.pk)
with self.assertRaises(InputValidationError):
load_node()
def test_creation_from_dbgroup(self):
n = Node().store()
g = Group(name='testgroup_from_dbgroup')
g.store()
g.add_nodes(n)
dbgroup = g.dbgroup
with self.assertRaises(ValueError):
# Cannot pass more parameters, even if valid, if
# dbgroup is specified
Group(dbgroup=dbgroup, name="test")
gcopy = Group(dbgroup=dbgroup)
self.assertEquals(g.pk, gcopy.pk)
self.assertEquals(g.uuid, gcopy.uuid)
# To avoid to find it in further tests
g.delete()