def test_get_session_fails_without_existing_connection(self):
"""
Users can't get the default session without having a default connection set.
"""
with self.assertRaisesRegexp(connection.CQLEngineException,
self.no_registered_connection_msg):
connection.get_session(connection=None)
def delete(self, username=None):
"""Delete a collection and the associated row in the tree entry table"""
from indigo.models import Notification
if self.is_root:
return
cfg = get_config(None)
session = connection.get_session()
keyspace = cfg.get('KEYSPACE', 'indigo')
session.set_keyspace(keyspace)
query = SimpleStatement(
"""DELETE FROM tree_entry WHERE container=%s""")
session.execute(query, (self.path, ))
# Get the row that describe the collection as a child of its parent
child = TreeEntry.objects.filter(container=self.container,
name=u"{}/".format(
self.name)).first()
if child:
child.delete()
session = get_graph_session()
session.execute_graph("""v_coll = {}.drop();
""".format(gq_get_vertex_collection(self)))
state = self.mqtt_get_state()
payload = self.mqtt_payload(state, {})
Notification.delete_collection(username, self.path, payload)
self.reset()
def test_default_consistency(self):
# verify that this session default is set according to connection.setup
# assumes tests/cqlengine/__init__ setup uses CL.ONE
session = connection.get_session()
self.assertEqual(
session.cluster.profile_manager.default.consistency_level,
ConsistencyLevel.ONE)
def test_static_columns(self):
class StaticModel(Model):
id = columns.Integer(primary_key=True)
c = columns.Integer(primary_key=True)
name = columns.Text(static=True)
drop_table(StaticModel)
session = get_session()
with mock.patch.object(session, "execute", wraps=session.execute) as m:
sync_table(StaticModel)
self.assertGreater(m.call_count, 0)
statement = m.call_args[0][0].query_string
self.assertIn('"name" text static', statement)
# if we sync again, we should not apply an alter w/ a static
sync_table(StaticModel)
with mock.patch.object(session, "execute",
wraps=session.execute) as m2:
sync_table(StaticModel)
self.assertEqual(len(m2.call_args_list), 0)
def delete_id(cls, uuid):
"""Delete all blobs for the specified uuid"""
cfg = get_config(None)
session = connection.get_session()
keyspace = cfg.get('KEYSPACE', 'indigo')
session.set_keyspace(keyspace)
query = SimpleStatement("""DELETE FROM data_object WHERE uuid=%s""")
session.execute(query, (uuid,))
def test_ttl_included_on_create(self):
""" tests that ttls on models work as expected """
session = get_session()
with mock.patch.object(session, 'execute') as m:
TestTTLModel.ttl(60).create(text="hello blake")
query = m.call_args[0][0].query_string
self.assertIn("USING TTL", query)
def test_update_includes_ttl(self):
session = get_session()
model = TestTTLModel.create(text="goodbye blake")
with mock.patch.object(session, 'execute') as m:
model.ttl(60).update(text="goodbye forever")
query = m.call_args[0][0].query_string
self.assertIn("USING TTL", query)
def get_default_ttl(self, table_name):
session = get_session()
try:
default_ttl = session.execute("SELECT default_time_to_live FROM system_schema.tables "
"WHERE keyspace_name = 'cqlengine_test' AND table_name = '{0}'".format(table_name))
except InvalidRequest:
default_ttl = session.execute("SELECT default_time_to_live FROM system.schema_columnfamilies "
"WHERE keyspace_name = 'cqlengine_test' AND columnfamily_name = '{0}'".format(table_name))
return default_ttl[0]['default_time_to_live']
def create_acl(self, acl_cql):
"""Replace the static acl with the given cql string"""
cfg = get_config(None)
session = connection.get_session()
keyspace = cfg.get('KEYSPACE', 'indigo')
session.set_keyspace(keyspace)
query = SimpleStatement(u"""UPDATE data_object SET acl = {}
WHERE uuid=%s""".format(acl_cql))
session.execute(query, (self.uuid,))
def update_container_acl(self, acl_cql):
"""Update the static acl with the given cql string"""
cfg = get_config(None)
session = connection.get_session()
keyspace = cfg.get('KEYSPACE', 'indigo')
session.set_keyspace(keyspace)
query = SimpleStatement(
u"""UPDATE tree_entry SET container_acl=container_acl+{}
WHERE container=%s""".format(acl_cql))
session.execute(query, (self.container, ))
def test_delete_on_subclass_does_not_include_disc_value(self):
p1 = Inherit1.create()
session = get_session()
with mock.patch.object(session, 'execute') as m:
Inherit1.objects(partition=p1.partition).delete()
# make sure our discriminator value isn't in the CQL
# not sure how we would even get here if it was in there
# since the CQL would fail.
self.assertNotIn("row_type", m.call_args[0][0].query_string)
def test_ttl_included_with_blind_update(self):
session = get_session()
o = TestTTLModel.create(text="whatever")
tid = o.id
with mock.patch.object(session, 'execute') as m:
TestTTLModel.objects(id=tid).ttl(60).update(text="bacon")
query = m.call_args[0][0].query_string
self.assertIn("USING TTL", query)
def delete_id(cls, uuid):
"""
Delete all blobs for the specified uuid
:param uuid: A CDMI uuid
:type uuid: str
"""
session = connection.get_session()
keyspace = radon.cfg.dse_keyspace
session.set_keyspace(keyspace)
query = SimpleStatement("""DELETE FROM data_object WHERE uuid=%s""")
session.execute(query, (uuid, ))
def test_ttl_is_include_with_query_on_update(self):
session = get_session()
o = TestTTLModel.create(text="whatever")
o.text = "new stuff"
o = o.ttl(60)
with mock.patch.object(session, 'execute') as m:
o.save()
query = m.call_args[0][0].query_string
self.assertIn("USING TTL", query)
def create_entry_acl(self, acl_cql):
"""Replace the acl with the given cql string
"""
cfg = get_config(None)
session = connection.get_session()
keyspace = cfg.get('KEYSPACE', 'indigo')
session.set_keyspace(keyspace)
query = SimpleStatement(u"""UPDATE tree_entry SET acl={}
WHERE container=%s and name=%s""".format(acl_cql))
session.execute(query, (
self.container,
self.name,
))
def test_override_default_ttl(self):
session = get_session()
o = TestDefaultTTLModel.create(text="some text on ttl")
tid = o.id
o.ttl(3600)
self.assertEqual(o._ttl, 3600)
with mock.patch.object(session, 'execute') as m:
TestDefaultTTLModel.objects(id=tid).ttl(None).update(text="aligators expired")
query = m.call_args[0][0].query_string
self.assertNotIn("USING TTL", query)
def create_acl(self, acl_cql):
"""
Replace the acl with the given cql string
:param acl_cql: The acl string to put in Cassandra, can be easily
generated in :meth:`radon.model.acl.acl_list_to_cql`
:type acl_cql: str
"""
session = connection.get_session()
keyspace = radon.cfg.dse_keyspace
session.set_keyspace(keyspace)
query = SimpleStatement(u"""UPDATE tree_node SET acl={}
WHERE container=%s and name=%s and version=%s""".format(acl_cql))
session.execute(query, (self.container, self.name, self.version))
def test_default_ttl_modify(self):
session = get_session()
default_ttl = self.get_default_ttl('test_default_ttlmodel')
self.assertEqual(default_ttl, 20)
TestDefaultTTLModel.__options__ = {'default_time_to_live': 10}
sync_table(TestDefaultTTLModel)
default_ttl = self.get_default_ttl('test_default_ttlmodel')
self.assertEqual(default_ttl, 10)
# Restore default TTL
TestDefaultTTLModel.__options__ = {'default_time_to_live': 20}
sync_table(TestDefaultTTLModel)
def test_default_ttl_not_set(self):
session = get_session()
o = TestTTLModel.create(text="some text")
tid = o.id
self.assertIsNone(o._ttl)
default_ttl = self.get_default_ttl('test_ttlmodel')
self.assertEqual(default_ttl, 0)
with mock.patch.object(session, 'execute') as m:
TestTTLModel.objects(id=tid).update(text="aligators")
query = m.call_args[0][0].query_string
self.assertNotIn("USING TTL", query)
def update(self, **kwargs):
"""Update a collection"""
cfg = get_config(None)
session = connection.get_session()
keyspace = cfg.get('KEYSPACE', 'indigo')
session.set_keyspace(keyspace)
for arg in kwargs:
# For static fields we can't use the name in the where condition
if arg in static_fields:
query = SimpleStatement(u"""UPDATE tree_entry SET {}=%s
WHERE container=%s""".format(arg))
session.execute(query, (kwargs[arg], self.container))
else:
query = SimpleStatement(u"""UPDATE tree_entry SET {}=%s
WHERE container=%s and name=%s""".format(arg))
session.execute(query,
(kwargs[arg], self.container, self.name))
return self
def test_default_ttl_set(self):
session = get_session()
o = TestDefaultTTLModel.create(text="some text on ttl")
tid = o.id
# Should not be set, it's handled by Cassandra
self.assertIsNone(o._ttl)
default_ttl = self.get_default_ttl('test_default_ttlmodel')
self.assertEqual(default_ttl, 20)
with mock.patch.object(session, 'execute') as m:
TestTTLModel.objects(id=tid).update(text="aligators expired")
# Should not be set either
query = m.call_args[0][0].query_string
self.assertNotIn("USING TTL", query)
def update(self, **kwargs):
"""Update a data object"""
cfg = get_config(None)
session = connection.get_session()
keyspace = cfg.get('KEYSPACE', 'indigo')
session.set_keyspace(keyspace)
for arg in kwargs:
# For static fields we can't use the name in the where condition
if arg in static_fields:
query = SimpleStatement("""UPDATE data_object SET {}=%s
WHERE uuid=%s""".format(arg))
session.execute(query, (kwargs[arg], self.uuid))
else:
print """UPDATE data_object SET {}=%s
WHERE uuid=%s and sequence_number=%s""".format(arg)
query = SimpleStatement("""UPDATE data_object SET {}=%s
WHERE uuid=%s and sequence_number=%s""".format(arg))
session.execute(query, (kwargs[arg], self.uuid, self.sequence_number))
return self
def delete(self, username=None):
"""
Delete a collection and the associated row in the tree_node table
:param username: The name of the user who deleted the collection
:type username: str, optional
"""
from radon.model import Resource
if not username:
username = radon.cfg.sys_lib_user
if self.is_root:
return
# We don't need the suffixes for the resources, otherwise we won't
# find them
child_container, child_dataobject = self.get_child(False)
for child_str in child_container:
child = Collection.find(self.path + child_str)
if child:
child.delete()
for child_str in child_dataobject:
child = Resource.find(self.path + child_str)
if child:
child.delete()
session = connection.get_session()
keyspace = radon.cfg.dse_keyspace
session.set_keyspace(keyspace)
query = SimpleStatement(
"""DELETE FROM tree_node WHERE container=%s and name=%s""")
session.execute(query, (
self.container,
self.name,
))
from radon.model import Notification
state = self.mqtt_get_state()
payload = self.mqtt_payload(state, {})
Notification.delete_collection(username, self.path, payload)
def setUp(self):
self.session = get_session()
