Example #1
0
def region_place(dict) :
    name= dict['location']
    if name == '' :
        name = dict['groupname']
    if Location.objects.filter(name=name).count() > 0 :
        return Location.objects.get(name=name)
    l = Location(name=name)
    l.save()
    return l
Example #2
0
def region_place(dict) :
    name= dict['location']
    if name == '' :
        name = dict['groupname']
    if Location.objects.filter(name=name).count() > 0 :
        return Location.objects.get(name=name)
    l = Location(name=name)
    l.save()
    return l
Example #3
0
    def test_contexts(self) :
        location = Location(name='world')
        location.save()

        u = User(username='******', email_address='*****@*****.**')
        u.save()

        group, created= TgGroup.objects.get_or_create(group_name='group',
                                                      display_name='Our Group', 
                                                      place=None, level='member', user=u)
        group.to_security_context()
        group.add_member(u)
        blog = group.create_OurPost(title='using defaults', creator=u)
        
        self.assertEquals(blog.get_inner().get_security_context().id, group.get_security_context().id)

        blog2 = group.create_OurPost(title='I did it my way', creator=u)

        sc2 = blog2.get_inner().to_security_context()
        blog2.get_inner().set_security_context(sc2)
        blog2.save()
        self.assertEquals(blog2.get_inner().get_security_context().id, sc2.id)
        self.assertNotEqual(blog2.get_inner().get_security_context().id, blog.get_inner().get_security_context().id)
Example #4
0
    def testExtras(self) :
        l = Location(name='someplace')
        l.save()
        tg = TgGroup(place=l,created=datetime.date.today())
        tg.save()
        extras = GroupExtras(about='this is about my group')
        extras.tg_group = tg

        self.assertEquals(tg.groupextras,extras)

        extras.save()
        e2 = GroupExtras.objects.get(pk=extras.pk)

        self.field(extras,'path','abc')
        self.field(extras,'title','abc')
        self.field(extras,'description','abc')
        self.field(extras,'body','abc')
        self.field(extras,'rights','abc')
        self.field(extras,'psn_id','abc')
        self.field(extras,'path','abcd')

        self.field(extras,'psn_id','abc')

        self.assertEquals(e2.about,"this is about my group")
Example #5
0
    def testExtras(self):
        l = Location(name='someplace')
        l.save()
        tg = TgGroup(place=l, created=datetime.date.today())
        tg.save()
        extras = GroupExtras(about='this is about my group')
        extras.tg_group = tg

        self.assertEquals(tg.groupextras, extras)

        extras.save()
        e2 = GroupExtras.objects.get(pk=extras.pk)

        self.field(extras, 'path', 'abc')
        self.field(extras, 'title', 'abc')
        self.field(extras, 'description', 'abc')
        self.field(extras, 'body', 'abc')
        self.field(extras, 'rights', 'abc')
        self.field(extras, 'psn_id', 'abc')
        self.field(extras, 'path', 'abcd')

        self.field(extras, 'psn_id', 'abc')

        self.assertEquals(e2.about, "this is about my group")
Example #6
0
    def testGroupHierarchy(self):
        # Test the group hierarchies stuff ...

        # make a user
        u = User(username='******',email_address='*****@*****.**')
        u.save()

        # and a couple more
        u2 = User(username='******',email_address='*****@*****.**')
        u2.save()
    
        u3 = User(username='******',email_address='*****@*****.**')
        u3.save()

        god = User(username='******', email_address='*****@*****.**')
        god.save()

        l = Location(name='kingsX')
        l.save()

        # here's a group (called "hub-members")
        hubMembers, flag = TgGroup.objects.get_or_create('hub-members',display_name='members', place=l, 
                                                         user=god, level='member')

        # they start with at least two members
        self.assertEquals(hubMembers.get_no_members(),2)

        # we now add member to the group
        hubMembers.add_member(u)
        # which now has three members
        self.assertEquals(hubMembers.get_no_members(),3)
        # and u is a member 
        self.assertTrue(u.is_member_of(hubMembers))
        
        # and hubMembers is itself in u's 'enclosures' (containing groups)
        self.assertTrue(hubMembers in set(u.get_enclosures()))

        # check that you can't add the same member twice
        hubMembers.add_member(u)
        self.assertEquals(hubMembers.get_no_members(),3)

        # another group, called hosts
        hosts,h2 = TgGroup.objects.get_or_create(group_name='admins', display_name='admins', place=l, 
                                                 user=god, level='member')
        hosts.save()

        # u2 is a host
        hosts.add_member(u2)

        # make hosts a member (sub-group) of hubMembers
        hubMembers.add_member(hosts) 
        
        # and check that it's counted as a member
        self.assertEquals(hubMembers.get_no_members(),4)

        # and hubMembers is in hosts' enclosures
        self.assertTrue(hubMembers in set(hosts.get_enclosures()))

        # and hosts is a member of members
        self.assertTrue(hosts.is_member_of(hubMembers))
        self.assertTrue(u2.is_member_of(hosts))

        # and membership is transitive
        self.assertTrue(u2.is_member_of(hubMembers))
        
        # but we haven't done anything crazy by making is_member_of just return false positives
        self.assertFalse(u.is_member_of(hosts))

        # nevertheless we can use is_direct_member_of to check for membership which is NOT transitive
        self.assertTrue(u2.is_direct_member_of(hosts))
        self.assertFalse(u2.is_direct_member_of(hubMembers))

        # Now we u becomes a member of subgroup hosts ... 
        hosts.add_member(u) 

        # it doesn't stop being a direct_member of hubMembers
        # which seems a bit messy, but it's dangerous to prune this given that membership is a lattice, not a tree
        self.assertTrue(u.is_direct_member_of(hosts))
        self.assertTrue(u.is_direct_member_of(hubMembers))
        self.assertTrue(u.is_member_of(hubMembers))

        another_group, created = TgGroup.objects.get_or_create(group_name='site_group',
                                                               display_name='Another Site Group',  
                                                               level='member', user=god)
        another_group.add_member(hubMembers)

        ag_hosts = another_group.get_admin_group() 

        self.assertTrue(ag_hosts.is_member_of(another_group))
        self.assertFalse(another_group.is_member_of(ag_hosts))

        # Now, if we ask for enclosure_set of u, we should get hubMembers and hosts
        es = u.get_enclosure_set()
        self.assertTrue(u in es)
        self.assertTrue(hosts in es)
        self.assertTrue(hubMembers in es)
        self.assertTrue(another_group in es)
        self.assertFalse(ag_hosts in es)
        self.assertFalse(u2 in es)


        # now let's see what happens when we remove membership
        hosts.remove_member(u)
        self.assertFalse(u.is_direct_member_of(hosts))
        self.assertFalse(u.is_member_of(hosts))