def test_create(self):
"""
"""
with patch.object(FakeStoragePlugin, 'create', return_value='ok'):
self.assertEquals(
self.storage_controller.create(
user_identifier='owner_identifier',
parent=tstdk.GAEnterprise(name='enterprise1'),
resource=tstdk.GAEnterprise(name='enterprise2')), 'ok')
def test_assign(self):
"""
"""
with patch.object(FakeStoragePlugin, 'assign', return_value='ok'):
self.assertEquals(
self.storage_controller.assign(
user_identifier='owner_identifier',
resource_name=tstdk.GAEnterprise(name='enterprise1'),
resources=[tstdk.GAEnterprise(name='enterprise2')],
parent='parent'), 'ok')
def test_push_multiple_events_order(self):
"""
"""
entity1 = tstdk.GAEnterprise(name='enterprise1')
entity2 = tstdk.GAEnterprise(name='enterprise2')
event1 = GAPushEvent(action=GARequest.ACTION_UPDATE, entity=entity1)
event2 = GAPushEvent(action=GARequest.ACTION_DELETE, entity=entity2)
notif = GAPushNotification(events=[event1, event2])
self.assertEquals(notif.events[0], event1)
self.assertEquals(notif.events[1], event2)
def test_make_response_for_read_all(self):
"""
"""
session = GASession(garuda_uuid='xxx-xxx-xxx-xxx')
request = GARequest(action=GARequest.ACTION_READALL)
context = GAContext(session=session, request=request)
enterprise1 = tstdk.GAEnterprise(name='enterprise1')
enterprise2 = tstdk.GAEnterprise(name='enterprise2')
context.objects = [enterprise1, enterprise2]
response = context.make_response()
self.assertEquals(response.__class__, GAResponseSuccess)
self.assertEquals(response.content, [enterprise1, enterprise2])
def test_to_dict(self):
"""
"""
enterprise = tstdk.GAEnterprise(name='enterprise1')
event = GAPushEvent(action=GARequest.ACTION_CREATE, entity=enterprise)
expected_result = {
'entities': [{
'description': None,
'zipcode': None,
'parentType': None,
'lastUpdatedDate': None,
'parentID': None,
'owner': None,
'creationDate': None,
'ID': None,
'name': 'enterprise1'
}],
'entityType':
'enterprise',
'type':
'CREATE',
'updateMechanism':
'DEFAULT'
}
converted = event.to_dict()
del converted['eventReceivedTime']
self.assertEqual(converted, expected_result)
def test_events_gets_deleted_with_session_expiration(self):
"""
"""
with patch.object(self.core_controller.sessions_controller,
'get_all_sessions',
return_value=[self.session]):
self.core_controller.sessions_controller._default_session_ttl = 1
session = self.core_controller.sessions_controller.create_session(
request='fake-request')
entity = tstdk.GAEnterprise(name='name', owner='user')
self.push_controller.push_events(
[GAPushEvent(action=GARequest.ACTION_CREATE, entity=entity)])
self.assertEquals(
self.push_controller.redis.llen(self.session_event_queue_key),
1)
self.assertFalse(
self.push_controller.is_event_queue_empty(
session=self.session))
import time
time.sleep(1.5)
self.assertEquals(
self.push_controller.redis.llen('eventqueue:%s' %
session.redis_key), 0)
self.assertTrue(
self.push_controller.is_event_queue_empty(session=session))
def test_instantiate(self):
"""
"""
with patch.object(FakeStoragePlugin,
'instantiate',
return_value=tstdk.GAEnterprise()):
self.assertEquals(
self.storage_controller.instantiate(
resource_name='test').rest_name, 'enterprise')
def test_push_notification_initialization(self):
"""
"""
entity1 = tstdk.GAEnterprise(name='enterprise1')
event1 = GAPushEvent(action=GARequest.ACTION_CREATE, entity=entity1)
notif = GAPushNotification(events=[event1])
self.assertEquals(notif.events[0], event1)
self.assertIsNotNone(notif.uuid)
def test_child_ids_with_permission(self):
"""
"""
enterprise = tstdk.GAEnterprise(owner='me')
self.assertEquals(
self.auth_plugin.child_ids_with_permission(resource='fake',
parent='fake',
children_type='fake',
permission='fake'),
'__OWNER_ONLY__')
def test_delete_multiple(self):
"""
"""
with patch.object(FakeStoragePlugin,
'delete_multiple',
return_value='ok'):
self.assertEquals(
self.storage_controller.delete_multiple(
user_identifier='owner_identifier',
resources=[tstdk.GAEnterprise(name='enterprise1')]), 'ok')
def test_add_events(self):
"""
"""
session = GASession(garuda_uuid='xxx-xxx-xxx-xxx')
request = GARequest(action=GARequest.ACTION_READ)
context = GAContext(session=session, request=request)
event1 = GAPushEvent(action=GARequest.ACTION_UPDATE,
entity=tstdk.GAEnterprise())
event2 = GAPushEvent(action=GARequest.ACTION_CREATE,
entity=tstdk.GAEnterprise())
event3 = GAPushEvent(action=GARequest.ACTION_DELETE,
entity=tstdk.GAEnterprise())
context.add_event(event1)
self.assertEquals(len(context.events), 1)
self.assertEquals(context.has_events, True)
context.add_events([event2, event3])
self.assertEquals(len(context.events), 3)
self.assertEquals(context.has_events, True)
def test_has_permission(self):
"""
"""
enterprise = tstdk.GAEnterprise(owner='me')
self.assertEquals(
self.auth_plugin.has_permission(resource='me',
target=enterprise,
permission='fake',
explicit_only=False), True)
self.assertEquals(
self.auth_plugin.has_permission(resource='not_me',
target=enterprise,
permission='fake',
explicit_only=False), False)
def test_make_response_for_assign(self):
"""
"""
session = GASession(garuda_uuid='xxx-xxx-xxx-xxx')
request = GARequest(action=GARequest.ACTION_ASSIGN)
context = GAContext(session=session, request=request)
enterprise1 = tstdk.GAEnterprise(name='enterprise1')
context.object = enterprise1
response = context.make_response()
self.assertEquals(response.__class__, GAResponseSuccess)
self.assertEquals(response.content, enterprise1)
def test_copy(self):
"""
"""
session = GASession(garuda_uuid='xxx-xxx-xxx-xxx')
request = GARequest(action=GARequest.ACTION_READ)
context = GAContext(session=session, request=request)
context.add_error(
GAError(type=GAError.TYPE_INVALID,
title='title1',
description='description2',
suggestion='nope',
property_name='prop1'))
context.add_error(
GAError(type=GAError.TYPE_CONFLICT,
title='title2',
description='description3',
suggestion='nope',
property_name='prop2'))
context.add_error(
GAError(type=GAError.TYPE_NOTFOUND,
title='title3',
description='description4',
suggestion='nope',
property_name='prop3'))
context.add_event(
GAPushEvent(action=GARequest.ACTION_UPDATE,
entity=tstdk.GAEnterprise()))
context.add_event(
GAPushEvent(action=GARequest.ACTION_CREATE,
entity=tstdk.GAEnterprise()))
context.add_event(
GAPushEvent(action=GARequest.ACTION_DELETE,
entity=tstdk.GAEnterprise()))
context.object = tstdk.GAEnterprise(name='enterprise1')
context.objects = [
tstdk.GAEnterprise(name='enterprise2'),
tstdk.GAEnterprise(name='enterprise3')
]
context_copy = context.copy()
self.assertEquals(context_copy.session.uuid, session.uuid)
self.assertEquals(context_copy.request.action, GARequest.ACTION_READ)
self.assertEquals([obj.name for obj in context_copy.objects],
[obj.name for obj in context.objects])
self.assertEquals(context_copy.object.name, context.object.name)
self.assertEquals(context_copy.has_errors, True)
self.assertEquals(len(context_copy.errors), 3)
self.assertEquals(context_copy.has_events, True)
self.assertEquals(len(context_copy.events), 3)
def test_compute_permission_redis_key(self):
"""
"""
target = tstdk.GAUser(username='******')
target.id = 'uid'
parent = tstdk.GAEnterprise(name='ent')
parent.id = 'pid'
key = self.redis_permissions_plugin._compute_permission_redis_key()
self.assertEquals(key, 'permission:*:*:*:*:*:*:*:*')
key = self.redis_permissions_plugin._compute_permission_redis_key(
permission_id='pid',
resource_id='rid',
target_type=target.rest_name,
target_id=target.id,
target_parent_type=parent.rest_name,
target_parent_id=parent.id,
scope='E')
self.assertEquals(key,
'permission:pid:*:rid:user:uid:enterprise:pid:E')
key = self.redis_permissions_plugin._compute_permission_redis_key(
permission_id='pid',
resource_id='rid',
target_type=target.rest_name,
target_id=target.id,
target_parent_type=parent.rest_name,
target_parent_id=parent.id,
scope='I')
self.assertEquals(key,
'permission:pid:*:rid:user:uid:enterprise:pid:I')
key = self.redis_permissions_plugin._compute_permission_redis_key(
permission_id='pid',
resource_id='rid',
target_type=target.rest_name,
target_id=target.id,
target_parent_type=parent.rest_name,
target_parent_id=parent.id,
scope='I',
parent_permission_id='ppid')
self.assertEquals(key,
'permission:pid:ppid:rid:user:uid:enterprise:pid:I')
def test_delete_push(self):
"""
"""
with patch.object(self.core_controller.sessions_controller,
'get_all_sessions',
return_value=[self.session]):
self.assertEquals(
self.push_controller.redis.llen(self.session_event_queue_key),
0)
self.assertTrue(
self.push_controller.is_event_queue_empty(
session=self.session))
entity = tstdk.GAEnterprise(name='name', owner='user')
self.push_controller.push_events(
[GAPushEvent(action=GARequest.ACTION_DELETE, entity=entity)])
event = self.push_controller.get_next_event(session=self.session)
self.assertIsNotNone(event)
self.assertEquals(event.action, GARequest.ACTION_DELETE)
self.assertEquals(entity.to_dict(), event.entity.to_dict())
def test_multiple_pushes(self):
"""
"""
with patch.object(self.core_controller.sessions_controller,
'get_all_sessions',
return_value=[self.session]):
self.assertEquals(
self.push_controller.redis.llen(self.session_event_queue_key),
0)
self.assertTrue(
self.push_controller.is_event_queue_empty(
session=self.session))
entity = tstdk.GAEnterprise(name='name', owner='user')
self.push_controller.push_events(
[GAPushEvent(action=GARequest.ACTION_CREATE, entity=entity)])
entity.name = 'modified'
self.push_controller.push_events(
[GAPushEvent(action=GARequest.ACTION_UPDATE, entity=entity)])
event1 = self.push_controller.get_next_event(session=self.session)
self.assertIsNotNone(event1)
self.assertEquals(event1.action, GARequest.ACTION_CREATE)
self.assertEquals(event1.entity.name, 'name')
self.assertFalse(
self.push_controller.is_event_queue_empty(
session=self.session))
event2 = self.push_controller.get_next_event(session=self.session)
self.assertIsNotNone(event2)
self.assertEquals(event2.action, GARequest.ACTION_UPDATE)
self.assertEquals(event2.entity.name, 'modified')
self.assertTrue(
self.push_controller.is_event_queue_empty(
session=self.session))
def test_push_event_creates_event_queue(self):
"""
"""
with patch.object(self.core_controller.sessions_controller,
'get_all_sessions',
return_value=[self.session]):
self.assertEquals(
self.push_controller.redis.llen(self.session_event_queue_key),
0)
self.assertTrue(
self.push_controller.is_event_queue_empty(
session=self.session))
entity = tstdk.GAEnterprise(name='name', owner='user')
self.push_controller.push_events(
[GAPushEvent(action=GARequest.ACTION_CREATE, entity=entity)])
self.assertEquals(
self.push_controller.redis.llen(self.session_event_queue_key),
1)
self.assertFalse(
self.push_controller.is_event_queue_empty(
session=self.session))
def test_serialize(self):
"""
"""
self.maxDiff = None
entity1 = tstdk.GAEnterprise(name='enterprise1')
entity2 = tstdk.GAEnterprise(name='enterprise2')
event1 = GAPushEvent(action=GARequest.ACTION_UPDATE, entity=entity1)
event2 = GAPushEvent(action=GARequest.ACTION_DELETE, entity=entity2)
notif = GAPushNotification(events=[event1, event2])
expected = {
'events': [{
'entities': [{
'ID': None,
'creationDate': None,
'description': None,
'lastUpdatedDate': None,
'name': 'enterprise1',
'owner': None,
'parentID': None,
'parentType': None,
'zipcode': None
}],
'entityType':
'enterprise',
'type':
'UPDATE',
'updateMechanism':
'DEFAULT'
}, {
'entities': [{
'ID': None,
'creationDate': None,
'description': None,
'lastUpdatedDate': None,
'name': 'enterprise2',
'owner': None,
'parentID': None,
'parentType': None,
'zipcode': None
}],
'entityType':
'enterprise',
'type':
'DELETE',
'updateMechanism':
'DEFAULT'
}]
}
data = notif.to_dict()
self.assertIsNotNone(data['events'][0]['eventReceivedTime'])
self.assertIsNotNone(data['events'][1]['eventReceivedTime'])
self.assertIsNotNone(data['uuid'])
del data['events'][0]['eventReceivedTime']
del data['events'][1]['eventReceivedTime']
del data['uuid']
self.assertEquals(data, expected)
def setUpClass(cls):
"""
Model:
e1 --- u1 --- a1
+-- u2 --- a2
+-- u3
e2 --- u4 --- a3
+-- u5 --- a4
--- a5
will be testing diverse permissions on that model for self.e0
"""
GASDKLibrary().register_sdk('default', tstdk)
cls.mongo_plugin = GAMongoStoragePlugin(db_name='permissions_test',
sdk_identifier='default')
cls.redis_permissions_plugin = GARedisPermissionsPlugin()
cls.core_controller = GACoreController(
garuda_uuid='test-garuda',
redis_info={
'host': '127.0.0.1',
'port': '6379',
'db': 7
},
storage_plugins=[cls.mongo_plugin],
permission_plugins=[cls.redis_permissions_plugin])
cls.storage_controller = cls.core_controller.storage_controller
cls.core_controller.redis.flushdb()
cls.core_controller.start()
cls.permissions_controller = cls.core_controller.permissions_controller
cls.e0 = tstdk.GAEnterprise(username='******')
cls.storage_controller.create(user_identifier='fake',
resource=cls.e0,
parent=None)
cls.e1 = tstdk.GAEnterprise(name='e1')
cls.e2 = tstdk.GAEnterprise(name='e2')
cls.u1 = tstdk.GAUser(username='******')
cls.u2 = tstdk.GAUser(username='******')
cls.u3 = tstdk.GAUser(username='******')
cls.u4 = tstdk.GAUser(username='******')
cls.u5 = tstdk.GAUser(username='******')
cls.a1 = tstdk.GAUser(street='a1')
cls.a2 = tstdk.GAUser(street='a2')
cls.a3 = tstdk.GAUser(street='a3')
cls.a4 = tstdk.GAUser(street='a4')
cls.a5 = tstdk.GAUser(street='a5')
cls.storage_controller.create(user_identifier='fake',
resource=cls.e1,
parent=None)
cls.storage_controller.create(user_identifier='fake',
resource=cls.u1,
parent=cls.e1)
cls.storage_controller.create(user_identifier='fake',
resource=cls.u2,
parent=cls.e1)
cls.storage_controller.create(user_identifier='fake',
resource=cls.u3,
parent=cls.e1)
cls.storage_controller.create(user_identifier='fake',
resource=cls.a1,
parent=cls.u1)
cls.storage_controller.create(user_identifier='fake',
resource=cls.a2,
parent=cls.u2)
cls.storage_controller.create(user_identifier='fake',
resource=cls.e2,
parent=None)
cls.storage_controller.create(user_identifier='fake',
resource=cls.u4,
parent=cls.e2)
cls.storage_controller.create(user_identifier='fake',
resource=cls.u5,
parent=cls.e2)
cls.storage_controller.create(user_identifier='fake',
resource=cls.a3,
parent=cls.u4)
cls.storage_controller.create(user_identifier='fake',
resource=cls.a4,
parent=cls.u5)
cls.storage_controller.create(user_identifier='fake',
resource=cls.a5,
parent=cls.u5)
