class TestOGDSService(OGDSTestCase):
def setUp(self):
super(TestOGDSService, self).setUp()
self.service = OGDSService(self.session)
def test_fetch_user_by_id(self):
jane = create(Builder('ogds_user').id('jane'))
self.assertEquals(jane, self.service.fetch_user("jane"))
def test_fetch_group_by_id(self):
group = create(Builder('ogds_group').id('group_a'))
self.assertEquals(group, self.service.fetch_group("group_a"))
def test_fetch_user_returns_none_when_no_user_found(self):
self.assertEquals(None, self.service.fetch_user("jane"))
def test_find_user_user_by_id(self):
jane = create(Builder('ogds_user').id('jane'))
self.assertEquals(jane, self.service.find_user("jane"))
def test_find_user_raise_when_no_user_found(self):
with self.assertRaises(RecordNotFound) as cm:
self.service.find_user("jane")
self.assertEquals("no User found for jane",
str(cm.exception))
def test_all_users_returns_a_list_of_every_user(self):
create(Builder('admin_unit').assign_org_units([
create(Builder('org_unit').id('unitc'))
]))
jane = create(Builder('ogds_user').id('jane'))
peter = create(Builder('ogds_user').id('peter'))
self.assertItemsEqual([jane, peter], self.service.all_users())
def test_all_users_returns_empty_list_when_no_user_exists(self):
self.assertEquals([], self.service.all_users())
def test_inactive_users_filters_by_active_false(self):
create(Builder('ogds_user').id('peter').having(active=True))
jane = create(Builder('ogds_user').id('jane').having(active=False))
self.assertItemsEqual([jane], self.service.inactive_users())
def test_filter_users(self):
jane = create(Builder('ogds_user').id('jane')
.having(firstname=u'Jane', lastname=u'Doe'))
john = create(Builder('ogds_user').id('john')
.having(firstname=u'John', lastname=u'doe'))
peter = create(Builder('ogds_user').id('peter')
.having(firstname=u'Peter', lastname=u'Peter'))
self.assertEqual([jane, john],
self.service.filter_users(['doe']).all())
def get_user_ids(self):
"""Returns a list of userids which represents the given watcher:
Means for a single user, a list with the user_id and for a inbox watcher,
a list of the userids of all inbox_group users.
"""
# XXX Use opengever.ogds.models.actor instead of own actor differentiation.
ogds_service = OGDSService(self.session)
if self.actorid.startswith("inbox:"):
org_unit_id = self.actorid.split(":", 1)[1]
org_unit = ogds_service.fetch_org_unit(org_unit_id)
return [user.userid for user in org_unit.inbox_group.users]
else:
return [self.actorid]
def get_user_ids(self):
"""Returns a list of userids which represents the given watcher:
Means for a single user, a list with the user_id and for a inbox watcher,
a list of the userids of all inbox_group users.
"""
# XXX Use opengever.ogds.models.actor instead of own actor differentiation.
ogds_service = OGDSService(self.session)
if self.actorid.startswith('inbox:'):
org_unit_id = self.actorid.split(':', 1)[1]
org_unit = ogds_service.fetch_org_unit(org_unit_id)
return [user.userid for user in org_unit.inbox_group.users]
else:
return [self.actorid]
class TestOrgUnitCounters(OGDSTestCase):
def setUp(self):
super(TestOrgUnitCounters, self).setUp()
self.service = OGDSService(self.session)
def test_has_multiple_org_units(self):
create(Builder('admin_unit').assign_org_units([
create(Builder('org_unit').id('unitc')),
create(Builder('org_unit').id('unita')),
create(Builder('org_unit').id('unitb')),
]))
self.assertTrue(self.service.has_multiple_org_units())
def test_falsy_multiple_org_units(self):
create(Builder('admin_unit').assign_org_units([
create(Builder('org_unit').id('unitc'))
]))
self.assertFalse(self.service.has_multiple_org_units())
def setUp(self):
super(TestOrgUnit, self).setUp()
self.service = OGDSService(self.session)
self.john = create(Builder('ogds_user').id('john'))
self.hugo = create(Builder('ogds_user').id('hugo'))
self.members = create(Builder('ogds_group')
.id('members')
.having(users=[self.john, self.hugo]))
self.org_unit = create(Builder('org_unit')
.id('unit')
.having(title='Unit A',
users_group=self.members,
inbox_group=self.members))
self.admin_unit = create(Builder('admin_unit')
.assign_org_units([self.org_unit]))
self.commit()
def setUp(self):
super(TestServiceOrgUnitMethods, self).setUp()
self.service = OGDSService(self.session)
self.hugo = create(Builder('ogds_user').id('hugo.boss'))
self.members = create(Builder('ogds_group')
.id('group_a')
.having(users=[self.hugo]))
self.inactive_group = create(Builder('ogds_group')
.id('group_b')
.having(active=False))
self.admin_unit_1 = create(Builder('admin_unit').id('admin_1')
.having(title='Admin Unit 1'))
self.admin_unit_2 = create(Builder('admin_unit').id('admin_2')
.having(enabled=False,
title='Admin Unit 2'))
self.admin_unit_3 = create(Builder('admin_unit').id('admin_3')
.having(title='Admin Unit 3'))
self.unit_c = create(Builder('org_unit').id('unitc').having(
title='Unit C',
users_group=self.members,
inbox_group=self.members,
admin_unit=self.admin_unit_1))
self.unit_a = create(Builder('org_unit').id('unita').having(
title='Unit A',
users_group=self.members,
inbox_group=self.members,
admin_unit=self.admin_unit_1))
self.unit_b = create(Builder('org_unit').id('unitb').having(
title='Unit B',
enabled=False,
users_group=self.members,
inbox_group=self.members,
admin_unit=self.admin_unit_1))
self.commit()
class TestOrgUnit(OGDSTestCase):
def setUp(self):
super(TestOrgUnit, self).setUp()
self.service = OGDSService(self.session)
self.john = create(Builder('ogds_user').id('john'))
self.hugo = create(Builder('ogds_user').id('hugo'))
self.members = create(Builder('ogds_group')
.id('members')
.having(users=[self.john, self.hugo]))
self.org_unit = create(Builder('org_unit')
.id('unit')
.having(title='Unit A',
users_group=self.members,
inbox_group=self.members))
self.admin_unit = create(Builder('admin_unit')
.assign_org_units([self.org_unit]))
self.commit()
def test_create_org_unit_id_required(self):
with self.assertRaises(TypeError):
OrgUnit()
def test_creatable(self):
org_units = self.session.query(OrgUnit).all()
self.assertEquals(len(org_units), 1)
unit = org_units[0]
self.assertEquals(unit.unit_id, 'unit')
def test_repr(self):
self.assertEquals(str(OrgUnit('a-unit')),
'<OrgUnit a-unit>')
def test_create_sets_attrs(self):
attrs = {
'unit_id': 'unit-two',
'title': 'Unit two',
'enabled': False,
}
c2 = OrgUnit(**attrs)
for key, value in attrs.items():
self.assertEquals(getattr(c2, key), value)
def test_representation_returns_OrgUnit_and_id(self):
self.assertEquals('<OrgUnit unit>', repr(self.org_unit))
def test_equality(self):
self.assertEqual(OrgUnit('aa'), OrgUnit('aa'))
self.assertNotEqual(OrgUnit('aa'), OrgUnit('bb'))
self.assertNotEqual(OrgUnit('aa'), OrgUnit(123))
self.assertNotEqual(OrgUnit('aa'), OrgUnit(None))
self.assertNotEqual(OrgUnit('aa'), object())
self.assertNotEqual(OrgUnit('aa'), None)
def test_label_returns_unit_title(self):
self.assertEquals(
'Unit A',
self.org_unit.label())
def test_id_returns_unit_id(self):
self.assertEquals(
'unit',
self.org_unit.id())
def test_assigned_users_returns_all_users_from_the_units_usersgroup(self):
self.assertItemsEqual([self.john, self.hugo],
self.org_unit.assigned_users())
def test_inbox_returns_inbox_according_to_the_org_unit(self):
inbox = self.org_unit.inbox()
self.assertEquals('inbox:unit', inbox.id())
self.assertEquals(self.org_unit, inbox._org_unit)
def test_label_is_not_prefixed_for_lone_org_unit(self):
org_unit = self.service.fetch_org_unit('unit')
self.assertEqual(u'a label', org_unit.prefix_label(u'a label'))
def test_label_is_prefixed_for_multiple_org_unit(self):
create(Builder('org_unit').id('unit-two')
.having(admin_unit=self.admin_unit))
org_unit = self.service.fetch_org_unit('unit')
self.assertEqual(u'Unit A / a label',
org_unit.prefix_label(u'a label'))
def test_inboxgroup_agency_is_inactive_for_lone_org_unit(self):
org_unit = self.service.fetch_org_unit('unit')
self.assertFalse(org_unit.is_inboxgroup_agency_active)
def test_inboxgroup_agency_is_active_for_multiple_org_units(self):
create(Builder('org_unit').id('unitb')
.having(admin_unit=self.admin_unit))
org_unit = self.service.fetch_org_unit('unit')
self.assertTrue(org_unit.is_inboxgroup_agency_active)
def setUp(self):
super(TestOGDSService, self).setUp()
self.service = OGDSService(self.session)
class TestServiceOrgUnitMethods(OGDSTestCase):
def setUp(self):
super(TestServiceOrgUnitMethods, self).setUp()
self.service = OGDSService(self.session)
self.hugo = create(Builder('ogds_user').id('hugo.boss'))
self.members = create(Builder('ogds_group')
.id('group_a')
.having(users=[self.hugo]))
self.inactive_group = create(Builder('ogds_group')
.id('group_b')
.having(active=False))
self.admin_unit_1 = create(Builder('admin_unit').id('admin_1')
.having(title='Admin Unit 1'))
self.admin_unit_2 = create(Builder('admin_unit').id('admin_2')
.having(enabled=False,
title='Admin Unit 2'))
self.admin_unit_3 = create(Builder('admin_unit').id('admin_3')
.having(title='Admin Unit 3'))
self.unit_c = create(Builder('org_unit').id('unitc').having(
title='Unit C',
users_group=self.members,
inbox_group=self.members,
admin_unit=self.admin_unit_1))
self.unit_a = create(Builder('org_unit').id('unita').having(
title='Unit A',
users_group=self.members,
inbox_group=self.members,
admin_unit=self.admin_unit_1))
self.unit_b = create(Builder('org_unit').id('unitb').having(
title='Unit B',
enabled=False,
users_group=self.members,
inbox_group=self.members,
admin_unit=self.admin_unit_1))
self.commit()
def test_has_multiple_admin_units(self):
self.assertTrue(self.service.has_multiple_admin_units())
def test_has_multiple_admin_units_counts_only_enabled_admin_units(self):
self.admin_unit_1.enabled = False
self.admin_unit_2.enabled = False
self.assertFalse(self.service.has_multiple_admin_units())
def test_fetch_org_unit_by_unit_id(self):
unit = self.service.fetch_org_unit('unitc')
self.assertEquals(self.unit_c, unit)
def test_fetch_org_unit_returns_none_when_no_org_unit_is_found(self):
self.assertIsNone(self.service.fetch_org_unit('not-existing-unit'))
def test_fetch_admin_unit_by_unit_id(self):
self.assertEquals(self.admin_unit_1,
self.service.fetch_admin_unit('admin_1'))
def test_fetching_disabled_admin_unit_by_unit_id(self):
self.assertEquals(self.admin_unit_2,
self.service.fetch_admin_unit('admin_2'))
def test_fetch_not_existing_admin_unit_returns_none(self):
self.assertIsNone(self.service.fetch_admin_unit('admin_xx'))
def test_assigned_org_units_returns_a_list_of_orgunit(self):
units = self.service.assigned_org_units('hugo.boss')
self.assertSequenceEqual([self.unit_a, self.unit_c], units)
def test_assigned_groups_returns_empty_list_if_no_groups_are_assigned(self):
create(Builder('ogds_user').id('chuck.norris'))
groups = self.service.assigned_groups('chuck.norris')
self.assertEqual([], groups)
def test_assigned_groups_returns_a_list_of_multiple_groups(self):
chuck = create(Builder('ogds_user').id('chuck.norris'))
administrators = create(Builder('ogds_group')
.id('administrators')
.having(users=[chuck]))
editors = create(Builder('ogds_group')
.id('editors')
.having(users=[chuck]))
groups = self.service.assigned_groups('chuck.norris')
self.assertSequenceEqual([administrators, editors], groups)
def test_all_org_units_returns_list_of_all_orgunits(self):
units = self.service.all_org_units()
self.assertSequenceEqual([self.unit_a, self.unit_c], units)
def test_all_org_units_includes_disabled_orgunits_when_flag_is_set(self):
units = self.service.all_org_units(enabled_only=False)
self.assertSequenceEqual([self.unit_a, self.unit_b, self.unit_c],
units)
def test_all_admin_units_returns_a_list_of_all_enabled_admin_units(self):
self.assertSequenceEqual([self.admin_unit_1, self.admin_unit_3],
self.service.all_admin_units())
def test_all_admin_units_includes_disabled_orgunits_when_flag_is_set(self):
self.assertSequenceEqual(
[self.admin_unit_1, self.admin_unit_2, self.admin_unit_3],
self.service.all_admin_units(enabled_only=False))
def test_all_groups_returns_active_groups_only_by_default(self):
self.assertItemsEqual([self.members], self.service.all_groups())
def test_all_groups_includes_inactive_groups_when_active_flag_is_false(self):
self.assertItemsEqual([self.members, self.inactive_group],
self.service.all_groups(active_only=False))
def setUp(self):
super(TestOrgUnitCounters, self).setUp()
self.service = OGDSService(self.session)
