def setUp(self):
yield super(DelegationCachingTest, self).setUp()
self.store = self.storeUnderTest()
self.groupCacher = GroupCacher(self.directory)
yield Delegates._memcacher.flushAll()
self.patch(CachingDelegates, "cacheNotifier", CapturingCacheNotifier())
def test_groups(self):
# A group must first be "refreshed" into the DB otherwise we won't
# consider it for group memberships
txn = self.store.newTransaction()
groupCacher = GroupCacher(self.directory)
yield groupCacher.refreshGroup(txn, u"__sub_group_1__")
yield txn.commit()
def setUp(self):
yield super(DynamicGroupTest, self).setUp()
self.directory = CalendarInMemoryDirectoryService(None)
self.store.setDirectoryService(self.directory)
self.groupCacher = GroupCacher(self.directory)
self.numUsers = 100
# Add users
records = []
fieldName = self.directory.fieldName
for i in xrange(self.numUsers):
records.append(
TestRecord(
self.directory,
{
fieldName.uid: u"foo{ctr:05d}".format(ctr=i),
fieldName.shortNames: (u"foo{ctr:05d}".format(ctr=i),),
fieldName.fullNames: (u"foo{ctr:05d}".format(ctr=i),),
fieldName.recordType: RecordType.user,
}
)
)
# Add two groups
for uid in (u"testgroup", u"emptygroup",):
records.append(
TestRecord(
self.directory,
{
fieldName.uid: uid,
fieldName.recordType: RecordType.group,
}
)
)
yield self.directory.updateRecords(records, create=True)
# add members to test group
group = yield self.directory.recordWithUID(u"testgroup")
members = yield self.directory.recordsWithRecordType(RecordType.user)
yield group.setMembers(members)
def doWork(self):
self.transaction._groupCacher = groupCacher
return unpatchedDoWork(self)
groupCacher = self.groupCacher
unpatchedDoWork = GroupRefreshWork.doWork
self.patch(GroupRefreshWork, "doWork", doWork)
config.AutomaticPurging.Enabled = True
def setUp(self):
yield super(DynamicGroupTest, self).setUp()
self.directory = CalendarInMemoryDirectoryService(None)
self.store.setDirectoryService(self.directory)
self.groupCacher = GroupCacher(self.directory)
self.numUsers = 100
# Add users
records = []
fieldName = self.directory.fieldName
for i in xrange(self.numUsers):
records.append(
TestRecord(
self.directory, {
fieldName.uid: u"foo{ctr:05d}".format(ctr=i),
fieldName.shortNames:
(u"foo{ctr:05d}".format(ctr=i), ),
fieldName.fullNames: (u"foo{ctr:05d}".format(ctr=i), ),
fieldName.recordType: RecordType.user,
}))
# Add a group
records.append(
TestRecord(
self.directory, {
fieldName.uid: u"testgroup",
fieldName.recordType: RecordType.group,
}))
yield self.directory.updateRecords(records, create=True)
group = yield self.directory.recordWithUID(u"testgroup")
members = yield self.directory.recordsWithRecordType(RecordType.user)
yield group.setMembers(members)
def setUp(self):
yield super(AugmentTest, self).setUp()
self.groupCacher = GroupCacher(self.directory)
def setUp(self):
yield super(DelegationTest, self).setUp()
self.store = self.storeUnderTest()
self.groupCacher = GroupCacher(self.directory)
def test_multiple_groups_with_individual_remove_from_one_group(self):
"""
Test that a multi-group share each containing the same user still lists the user
when they are removed from one group.
"""
@inlineCallbacks
def expandedMembers(self, records=None, seen=None):
if self.uid == "group05":
returnValue(frozenset())
else:
returnValue((yield
unpatchedExpandedMembers(self, records, seen)))
unpatchedExpandedMembers = CalendarDirectoryRecordMixin.expandedMembers
# setup group cacher
groupCacher = GroupCacher(
self.transactionUnderTest().directoryService())
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 0)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group05")
self.assertEqual(len(wps), 0)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group06")
self.assertEqual(len(wps), 0)
# Invite
calendar = yield self.calendarUnderTest(home="user03", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 0)
self.assertFalse(calendar.isSharedByOwner())
shareeView = yield calendar.inviteUIDToShare("user01", _BIND_MODE_READ)
self.assertTrue(shareeView is not None)
shareeViews = yield calendar.inviteUIDToShare("group05",
_BIND_MODE_WRITE)
self.assertEqual(len(shareeViews), 2)
shareeViews = yield calendar.inviteUIDToShare("group06",
_BIND_MODE_READ)
self.assertEqual(len(shareeViews), 1)
calendar = yield self.calendarUnderTest(home="user03", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 2)
for invite in invites:
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user03")
self.assertEqual(invite.uid, shareeView.shareName())
if invite.shareeUID == "user01":
self.assertEqual(invite.mode, _BIND_MODE_GROUP_READ)
else:
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_WRITE)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 2)
# Change group membership
self.patch(CalendarDirectoryRecordMixin, "expandedMembers",
expandedMembers)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group05")
self.assertEqual(len(wps), 1)
yield self.commit()
yield JobItem.waitEmpty(self._sqlCalendarStore.newTransaction, reactor,
60)
calendar = yield self.calendarUnderTest(home="user03", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 2)
for invite in invites:
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user03")
self.assertEqual(invite.uid, shareeView.shareName())
if invite.shareeUID == "user01":
self.assertEqual(invite.mode, _BIND_MODE_READ)
else:
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_READ)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
# Uninvite
calendar = yield self.calendarUnderTest(home="user03", name="calendar")
yield calendar.uninviteUIDFromShare("user01")
yield calendar.uninviteUIDFromShare("group05")
yield calendar.uninviteUIDFromShare("group06")
noinvites = yield calendar.sharingInvites()
self.assertEqual(len(noinvites), 0)
def test_group_change_removed_calendar(self):
"""
Test that group shares are properly cleaned when a calendar is removed (and not trashed).
"""
self.patch(config, "EnableTrashCollection", False)
@inlineCallbacks
def expandedMembers(self, records=None, seen=None):
if self.uid == "group02":
returnValue(frozenset())
else:
returnValue((yield
unpatchedExpandedMembers(self, records, seen)))
unpatchedExpandedMembers = CalendarDirectoryRecordMixin.expandedMembers
# setup group cacher
groupCacher = GroupCacher(
self.transactionUnderTest().directoryService())
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 0)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group02")
self.assertEqual(len(wps), 0)
yield self._check_notifications("user01", [])
# New calendar for sharing
home = yield self.homeUnderTest(name="user01")
yield home.createCalendarWithName("shared")
yield self.commit()
# Invite
calendar = yield self.calendarUnderTest(home="user01", name="shared")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 0)
self.assertFalse(calendar.isSharedByOwner())
yield self._check_notifications("user01", [])
shareeViews = yield calendar.inviteUIDToShare("group02",
_BIND_MODE_READ)
self.assertEqual(len(shareeViews), 3)
calendar = yield self.calendarUnderTest(home="user01", name="shared")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 3)
for invite in invites:
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user01")
self.assertEqual(invite.uid, shareeView.shareName())
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_READ)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 1)
yield self.commit()
# Remove the collection
calendar = yield self.calendarUnderTest(home="user01", name="shared")
remove_id = calendar.id()
yield calendar.remove()
yield self.commit()
home = yield self.homeUnderTest(name="user01")
calendar = yield home.childWithID(remove_id)
self.assertTrue(calendar is None)
calendar = yield home.childWithID(remove_id, onlyInTrash=True)
self.assertTrue(calendar is None)
yield self.commit()
# 1 group member
self.patch(CalendarDirectoryRecordMixin, "expandedMembers",
expandedMembers)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group02")
self.assertEqual(len(wps), 0)
yield self.commit()
yield JobItem.waitEmpty(self._sqlCalendarStore.newTransaction, reactor,
60)
def test_no_self_invite_on_add(self):
"""
Test that the sharee is not invited to their own share when they are added as a member
of a group to whom the calendar is shared.
"""
record01 = yield self.transactionUnderTest().directoryService(
).recordWithUID("user01")
record02 = yield self.transactionUnderTest().directoryService(
).recordWithUID("user02")
@inlineCallbacks
def expandedMembers(self, records=None, seen=None):
if self.uid == "group06":
returnValue(frozenset((
record01,
record02,
)))
else:
returnValue((yield
unpatchedExpandedMembers(self, records, seen)))
unpatchedExpandedMembers = CalendarDirectoryRecordMixin.expandedMembers
# setup group cacher
groupCacher = GroupCacher(
self.transactionUnderTest().directoryService())
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 0)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group06")
self.assertEqual(len(wps), 0)
yield self._check_notifications("user01", [])
# Invite
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 0)
self.assertFalse(calendar.isSharedByOwner())
yield self._check_notifications("user01", [])
shareeViews = yield calendar.inviteUIDToShare("group06",
_BIND_MODE_READ)
self.assertEqual(len(shareeViews), 1)
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 1)
for invite in invites:
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user01")
self.assertEqual(invite.uid, shareeView.shareName())
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_READ)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
# 1 group members
self.patch(CalendarDirectoryRecordMixin, "expandedMembers",
expandedMembers)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group06")
self.assertEqual(len(wps), 1)
yield self.commit()
yield JobItem.waitEmpty(self._sqlCalendarStore.newTransaction, reactor,
60)
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 1)
for invite in invites:
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user01")
self.assertEqual(invite.uid, shareeView.shareName())
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_READ)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
yield self._check_notifications("user01", [])
# Uninvite
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
yield calendar.uninviteUIDFromShare("group06")
noinvites = yield calendar.sharingInvites()
self.assertEqual(len(noinvites), 0)
def test_group_member_removal_refresh_slow(self):
"""
Test that the sharee list is still valid when a member is removed from a group, but
sharee reconciliation has not yet occurred.
"""
@inlineCallbacks
def expandedMembers(self, records=None, seen=None):
if self.uid == "group02":
returnValue(frozenset())
else:
returnValue((yield
unpatchedExpandedMembers(self, records, seen)))
unpatchedExpandedMembers = CalendarDirectoryRecordMixin.expandedMembers
# Prevent sharee reconciliation
def _noop(self):
return succeed(None)
self.patch(GroupShareeReconciliationWork, "doWork", _noop)
# setup group cacher
groupCacher = GroupCacher(
self.transactionUnderTest().directoryService())
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 0)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group02")
self.assertEqual(len(wps), 0)
yield self._check_notifications("user01", [])
# Invite
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 0)
self.assertFalse(calendar.isSharedByOwner())
yield self._check_notifications("user01", [])
shareeViews = yield calendar.inviteUIDToShare("group02",
_BIND_MODE_READ)
self.assertEqual(len(shareeViews), 3)
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 3)
for invite in invites:
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user01")
self.assertEqual(invite.uid, shareeView.shareName())
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_READ)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 1)
# 0 group members
self.patch(CalendarDirectoryRecordMixin, "expandedMembers",
expandedMembers)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group02")
self.assertEqual(len(wps), 1)
yield self.commit()
yield JobItem.waitEmpty(self._sqlCalendarStore.newTransaction, reactor,
60)
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 3)
for invite in invites:
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user01")
self.assertEqual(invite.uid, shareeView.shareName())
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_READ)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
yield self._check_notifications("user01", [])
# Uninvite
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
yield calendar.uninviteUIDFromShare("group02")
noinvites = yield calendar.sharingInvites()
self.assertEqual(len(noinvites), 3)
def test_group_change_invite_larger(self):
"""
Test that group shares are changed when the group changes.
"""
@inlineCallbacks
def expandedMembers(self, records=None, seen=None):
if self.uid == "group02" or self.uid == "group03":
returnValue(frozenset())
else:
returnValue((yield
unpatchedExpandedMembers(self, records, seen)))
unpatchedExpandedMembers = CalendarDirectoryRecordMixin.expandedMembers
# 1 group member
self.patch(CalendarDirectoryRecordMixin, "expandedMembers",
expandedMembers)
# setup group cacher
groupCacher = GroupCacher(
self.transactionUnderTest().directoryService())
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 0)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group04")
self.assertEqual(len(wps), 0)
yield self._check_notifications("user01", [])
# Invite
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 0)
self.assertFalse(calendar.isSharedByOwner())
yield self._check_notifications("user01", [])
shareeViews = yield calendar.inviteUIDToShare("group04",
_BIND_MODE_READ)
self.assertEqual(len(shareeViews), 1)
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 1)
for invite in invites:
self.assertEqual(invite.shareeUID, "user10")
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user01")
self.assertEqual(invite.uid, shareeView.shareName())
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_READ)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
groupsToRefresh = yield groupCacher.groupsToRefresh(
self.transactionUnderTest())
self.assertEqual(len(groupsToRefresh), 1)
# group members restored
self.patch(CalendarDirectoryRecordMixin, "expandedMembers",
unpatchedExpandedMembers)
wps = yield groupCacher.refreshGroup(self.transactionUnderTest(),
"group04")
self.assertEqual(len(wps), 1)
yield self.commit()
yield JobItem.waitEmpty(self._sqlCalendarStore.newTransaction, reactor,
60)
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
invites = yield calendar.sharingInvites()
self.assertEqual(len(invites), 5)
for invite in invites:
shareeView = yield calendar.shareeView(invite.shareeUID)
self.assertEqual(invite.ownerUID, "user01")
self.assertEqual(invite.uid, shareeView.shareName())
self.assertEqual(invite.mode, _BIND_MODE_GROUP)
self.assertEqual((yield shareeView.effectiveShareMode()),
_BIND_MODE_READ)
self.assertEqual(invite.status, _BIND_STATUS_INVITED)
self.assertEqual(invite.summary, None)
yield self._check_notifications(invite.shareeUID, [
invite.uid,
])
# Uninvite
calendar = yield self.calendarUnderTest(home="user01", name="calendar")
yield calendar.uninviteUIDFromShare("group04")
noinvites = yield calendar.sharingInvites()
self.assertEqual(len(noinvites), 0)
def test_directoryBasedDelegationChanges(self):
groupCacher = GroupCacher(self.directory)
delegator = yield self.directory.recordWithUID(u"__wsanchez1__")
groupRecord1 = yield self.directory.recordWithUID(u"__top_group_1__")
group1 = yield self.transactionUnderTest().groupByUID("__top_group_1__")
groupRecord2 = yield self.directory.recordWithUID(u"__sub_group_1__")
group2 = yield self.transactionUnderTest().groupByUID("__sub_group_1__")
groupRecord3 = yield self.directory.recordWithUID(u"left_coast")
group3 = yield self.transactionUnderTest().groupByUID("left_coast")
delegate = yield self.directory.recordWithUID(u"__sagen1__")
# No delegates
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 0)
# No delegators to this group
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 0)
# User is not a delegate
delegators = yield Delegates.delegatedTo(self.transactionUnderTest(), delegate, True)
self.assertEquals(len(delegators), 0)
# Apply an external read-only assignment
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, groupRecord1.uid, None
)
# Now there is a read-only delegate
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 1)
# Now this group is read-only delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 1)
# Apply an external read-write assignment
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, groupRecord1.uid, groupRecord2.uid
)
# Now there are read-only and read-write delegates
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 1)
self.assertEquals(delegates[0].uid, "__top_group_1__")
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, True)
self.assertEquals(len(delegates), 1)
self.assertEquals(delegates[0].uid, "__sub_group_1__")
# Now both groups are delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 1)
delegators = yield self.transactionUnderTest().delegatorsToGroup(group2.groupID, True)
self.assertEquals(len(delegators), 1)
# User is now a delegate (cache must have been invalidated properly)
delegators = yield Delegates.delegatedTo(self.transactionUnderTest(), delegate, True)
self.assertEquals(len(delegators), 1)
# Change read-write assignment
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, groupRecord1.uid, groupRecord3.uid
)
# Now this group is not delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group2.groupID, True)
self.assertEquals(len(delegators), 0)
# ..but this group is delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group3.groupID, True)
self.assertEquals(len(delegators), 1)
# Remove external read-write assignment
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, groupRecord1.uid, None
)
# Now there is only a read-only delegate
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 1)
self.assertEquals(delegates[0].uid, "__top_group_1__")
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, True)
self.assertEquals(len(delegates), 0)
# Now this group is read-only delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 1)
# Now this group is not delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group3.groupID, True)
self.assertEquals(len(delegators), 0)
# User is not a delegate anymore (cache must have been invalidated properly)
delegators = yield Delegates.delegatedTo(self.transactionUnderTest(), delegate, True)
self.assertEquals(len(delegators), 0)
# Remove external assignments altogether
yield groupCacher.applyExternalAssignments(
self.transactionUnderTest(), delegator.uid, None, None
)
# Now there are no delegates
delegates = yield Delegates.delegatesOf(self.transactionUnderTest(), delegator, False)
self.assertEquals(len(delegates), 0)
# No groups are delegated to
delegators = yield self.transactionUnderTest().delegatorsToGroup(group1.groupID, False)
self.assertEquals(len(delegators), 0)
delegators = yield self.transactionUnderTest().delegatorsToGroup(group2.groupID, True)
self.assertEquals(len(delegators), 0)
delegators = yield self.transactionUnderTest().delegatorsToGroup(group3.groupID, True)
self.assertEquals(len(delegators), 0)
def setUp(self):
yield super(DelegationTest, self).setUp()
self.store = self.storeUnderTest()
self.groupCacher = GroupCacher(self.directory)
yield Delegates._memcacher.flushAll()
