def test_ordering_limits_offsets_sqla(self):
"""Test ordering limits offsets of SQLA query results."""
# Creating 10 nodes with an attribute that can be ordered
for i in range(10):
node = Data()
node.set_attribute('foo', i)
node.store()
q_b = QueryBuilder().append(Node, project='attributes.foo').order_by(
{Node: {
'attributes.foo': {
'cast': 'i'
}
}})
res = next(zip(*q_b.all()))
self.assertEqual(res, tuple(range(10)))
# Now applying an offset:
q_b.offset(5)
res = next(zip(*q_b.all()))
self.assertEqual(res, tuple(range(5, 10)))
# Now also applying a limit:
q_b.limit(3)
res = next(zip(*q_b.all()))
self.assertEqual(res, tuple(range(5, 8)))
def test_ordering_limits_offsets_of_results_for_SQLA(self):
from aiida.orm import Node, Data
from aiida.orm.querybuilder import QueryBuilder
# Creating 10 nodes with an attribute that can be ordered
for i in range(10):
n = Data()
n.set_attribute('foo', i)
n.store()
qb = QueryBuilder().append(
Node, project='attributes.foo'
).order_by(
{Node: {'attributes.foo': {'cast': 'i'}}}
)
res = next(zip(*qb.all()))
self.assertEqual(res, tuple(range(10)))
# Now applying an offset:
qb.offset(5)
res = next(zip(*qb.all()))
self.assertEqual(res, tuple(range(5, 10)))
# Now also applying a limit:
qb.limit(3)
res = next(zip(*qb.all()))
self.assertEqual(res, tuple(range(5, 8)))
class TestNodeAttributesExtras(AiidaTestCase):
"""Test for node attributes and extras."""
def setUp(self):
super(TestNodeAttributesExtras, self).setUp()
self.node = Data()
def test_attributes(self):
"""Test the `Node.attributes` property."""
original_attribute = {'nested': {'a': 1}}
self.node.set_attribute('key', original_attribute)
node_attributes = self.node.attributes
self.assertEqual(node_attributes['key'], original_attribute)
node_attributes['key']['nested']['a'] = 2
self.assertEqual(original_attribute['nested']['a'], 2)
# Now store the node and verify that `attributes` then returns a deep copy
self.node.store()
node_attributes = self.node.attributes
# We change the returned node attributes but the original attribute should remain unchanged
node_attributes['key']['nested']['a'] = 3
self.assertEqual(original_attribute['nested']['a'], 2)
def test_get_attribute(self):
"""Test the `Node.get_attribute` method."""
original_attribute = {'nested': {'a': 1}}
self.node.set_attribute('key', original_attribute)
node_attribute = self.node.get_attribute('key')
self.assertEqual(node_attribute, original_attribute)
node_attribute['nested']['a'] = 2
self.assertEqual(original_attribute['nested']['a'], 2)
default = 'default'
self.assertEqual(self.node.get_attribute('not_existing', default=default), default)
with self.assertRaises(AttributeError):
self.node.get_attribute('not_existing')
# Now store the node and verify that `get_attribute` then returns a deep copy
self.node.store()
node_attribute = self.node.get_attribute('key')
# We change the returned node attributes but the original attribute should remain unchanged
node_attribute['nested']['a'] = 3
self.assertEqual(original_attribute['nested']['a'], 2)
default = 'default'
self.assertEqual(self.node.get_attribute('not_existing', default=default), default)
with self.assertRaises(AttributeError):
self.node.get_attribute('not_existing')
def test_get_attribute_many(self):
"""Test the `Node.get_attribute_many` method."""
original_attribute = {'nested': {'a': 1}}
self.node.set_attribute('key', original_attribute)
node_attribute = self.node.get_attribute_many(['key'])[0]
self.assertEqual(node_attribute, original_attribute)
node_attribute['nested']['a'] = 2
self.assertEqual(original_attribute['nested']['a'], 2)
# Now store the node and verify that `get_attribute` then returns a deep copy
self.node.store()
node_attribute = self.node.get_attribute_many(['key'])[0]
# We change the returned node attributes but the original attribute should remain unchanged
node_attribute['nested']['a'] = 3
self.assertEqual(original_attribute['nested']['a'], 2)
def test_set_attribute(self):
"""Test the `Node.set_attribute` method."""
with self.assertRaises(exceptions.ValidationError):
self.node.set_attribute('illegal.key', 'value')
self.node.set_attribute('valid_key', 'value')
self.node.store()
with self.assertRaises(exceptions.ModificationNotAllowed):
self.node.set_attribute('valid_key', 'value')
def test_set_attribute_many(self):
"""Test the `Node.set_attribute` method."""
with self.assertRaises(exceptions.ValidationError):
self.node.set_attribute_many({'illegal.key': 'value', 'valid_key': 'value'})
self.node.set_attribute_many({'valid_key': 'value'})
self.node.store()
with self.assertRaises(exceptions.ModificationNotAllowed):
self.node.set_attribute_many({'valid_key': 'value'})
def test_reset_attribute(self):
"""Test the `Node.reset_attribute` method."""
attributes_before = {'attribute_one': 'value', 'attribute_two': 'value'}
attributes_after = {'attribute_three': 'value', 'attribute_four': 'value'}
attributes_illegal = {'attribute.illegal': 'value', 'attribute_four': 'value'}
self.node.set_attribute_many(attributes_before)
self.assertEqual(self.node.attributes, attributes_before)
self.node.reset_attributes(attributes_after)
self.assertEqual(self.node.attributes, attributes_after)
with self.assertRaises(exceptions.ValidationError):
self.node.reset_attributes(attributes_illegal)
self.node.store()
with self.assertRaises(exceptions.ModificationNotAllowed):
self.node.reset_attributes(attributes_after)
def test_delete_attribute(self):
"""Test the `Node.delete_attribute` method."""
self.node.set_attribute('valid_key', 'value')
self.assertEqual(self.node.get_attribute('valid_key'), 'value')
self.node.delete_attribute('valid_key')
with self.assertRaises(AttributeError):
self.node.delete_attribute('valid_key')
# Repeat with stored node
self.node.set_attribute('valid_key', 'value')
self.node.store()
with self.assertRaises(exceptions.ModificationNotAllowed):
self.node.delete_attribute('valid_key')
def test_delete_attribute_many(self):
"""Test the `Node.delete_attribute_many` method."""
def test_clear_attributes(self):
"""Test the `Node.clear_attributes` method."""
attributes = {'attribute_one': 'value', 'attribute_two': 'value'}
self.node.set_attribute_many(attributes)
self.assertEqual(self.node.attributes, attributes)
self.node.clear_attributes()
self.assertEqual(self.node.attributes, {})
# Repeat for stored node
self.node.store()
with self.assertRaises(exceptions.ModificationNotAllowed):
self.node.clear_attributes()
def test_attributes_items(self):
"""Test the `Node.attributes_items` generator."""
attributes = {'attribute_one': 'value', 'attribute_two': 'value'}
self.node.set_attribute_many(attributes)
self.assertEqual(dict(self.node.attributes_items()), attributes)
def test_attributes_keys(self):
"""Test the `Node.attributes_keys` generator."""
attributes = {'attribute_one': 'value', 'attribute_two': 'value'}
self.node.set_attribute_many(attributes)
self.assertEqual(set(self.node.attributes_keys()), set(attributes))
def test_extras(self):
"""Test the `Node.extras` property."""
original_extra = {'nested': {'a': 1}}
self.node.set_extra('key', original_extra)
node_extras = self.node.extras
self.assertEqual(node_extras['key'], original_extra)
node_extras['key']['nested']['a'] = 2
self.assertEqual(original_extra['nested']['a'], 2)
# Now store the node and verify that `extras` then returns a deep copy
self.node.store()
node_extras = self.node.extras
# We change the returned node extras but the original extra should remain unchanged
node_extras['key']['nested']['a'] = 3
self.assertEqual(original_extra['nested']['a'], 2)
def test_get_extra(self):
"""Test the `Node.get_extra` method."""
original_extra = {'nested': {'a': 1}}
self.node.set_extra('key', original_extra)
node_extra = self.node.get_extra('key')
self.assertEqual(node_extra, original_extra)
node_extra['nested']['a'] = 2
self.assertEqual(original_extra['nested']['a'], 2)
default = 'default'
self.assertEqual(self.node.get_extra('not_existing', default=default), default)
with self.assertRaises(AttributeError):
self.node.get_extra('not_existing')
# Now store the node and verify that `get_extra` then returns a deep copy
self.node.store()
node_extra = self.node.get_extra('key')
# We change the returned node extras but the original extra should remain unchanged
node_extra['nested']['a'] = 3
self.assertEqual(original_extra['nested']['a'], 2)
default = 'default'
self.assertEqual(self.node.get_extra('not_existing', default=default), default)
with self.assertRaises(AttributeError):
self.node.get_extra('not_existing')
def test_get_extra_many(self):
"""Test the `Node.get_extra_many` method."""
original_extra = {'nested': {'a': 1}}
self.node.set_extra('key', original_extra)
node_extra = self.node.get_extra_many(['key'])[0]
self.assertEqual(node_extra, original_extra)
node_extra['nested']['a'] = 2
self.assertEqual(original_extra['nested']['a'], 2)
# Now store the node and verify that `get_extra` then returns a deep copy
self.node.store()
node_extra = self.node.get_extra_many(['key'])[0]
# We change the returned node extras but the original extra should remain unchanged
node_extra['nested']['a'] = 3
self.assertEqual(original_extra['nested']['a'], 2)
def test_set_extra(self):
"""Test the `Node.set_extra` method."""
with self.assertRaises(exceptions.ValidationError):
self.node.set_extra('illegal.key', 'value')
self.node.set_extra('valid_key', 'value')
self.node.store()
self.node.set_extra('valid_key', 'changed')
self.assertEqual(load_node(self.node.pk).get_extra('valid_key'), 'changed')
def test_set_extra_many(self):
"""Test the `Node.set_extra` method."""
with self.assertRaises(exceptions.ValidationError):
self.node.set_extra_many({'illegal.key': 'value', 'valid_key': 'value'})
self.node.set_extra_many({'valid_key': 'value'})
self.node.store()
self.node.set_extra_many({'valid_key': 'changed'})
self.assertEqual(load_node(self.node.pk).get_extra('valid_key'), 'changed')
def test_reset_extra(self):
"""Test the `Node.reset_extra` method."""
extras_before = {'extra_one': 'value', 'extra_two': 'value'}
extras_after = {'extra_three': 'value', 'extra_four': 'value'}
extras_illegal = {'extra.illegal': 'value', 'extra_four': 'value'}
self.node.set_extra_many(extras_before)
self.assertEqual(self.node.extras, extras_before)
self.node.reset_extras(extras_after)
self.assertEqual(self.node.extras, extras_after)
with self.assertRaises(exceptions.ValidationError):
self.node.reset_extras(extras_illegal)
self.node.store()
self.node.reset_extras(extras_after)
self.assertEqual(load_node(self.node.pk).extras, extras_after)
def test_delete_extra(self):
"""Test the `Node.delete_extra` method."""
self.node.set_extra('valid_key', 'value')
self.assertEqual(self.node.get_extra('valid_key'), 'value')
self.node.delete_extra('valid_key')
with self.assertRaises(AttributeError):
self.node.delete_extra('valid_key')
# Repeat with stored node
self.node.set_extra('valid_key', 'value')
self.node.store()
self.node.delete_extra('valid_key')
with self.assertRaises(AttributeError):
load_node(self.node.pk).get_extra('valid_key')
def test_delete_extra_many(self):
"""Test the `Node.delete_extra_many` method."""
def test_clear_extras(self):
"""Test the `Node.clear_extras` method."""
extras = {'extra_one': 'value', 'extra_two': 'value'}
self.node.set_extra_many(extras)
self.assertEqual(self.node.extras, extras)
self.node.clear_extras()
self.assertEqual(self.node.extras, {})
# Repeat for stored node
self.node.store()
self.node.clear_extras()
self.assertEqual(load_node(self.node.pk).extras, {})
def test_extras_items(self):
"""Test the `Node.extras_items` generator."""
extras = {'extra_one': 'value', 'extra_two': 'value'}
self.node.set_extra_many(extras)
self.assertEqual(dict(self.node.extras_items()), extras)
def test_extras_keys(self):
"""Test the `Node.extras_keys` generator."""
extras = {'extra_one': 'value', 'extra_two': 'value'}
self.node.set_extra_many(extras)
self.assertEqual(set(self.node.extras_keys()), set(extras))
