← Back to branch summary

~ubuntu-branches/ubuntu/natty/moin/natty-updates

« back to all changes in this revision

Viewing changes to MoinMoin/datastruct/backends/_tests/test_wiki_groups.py

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2008-06-22 21:17:13 UTC
  • mto: This revision was merged to the branch mainline in revision 18.
  • Revision ID: james.westby@ubuntu.com-20080622211713-inlv5k4eifxckelr
Import upstream version 1.7.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
MoinMoin/datastruct/backends/_tests/test_wiki_groups.py
1
 
# -*- coding: iso-8859-1 -*-
2
 
"""
3
 
MoinMoin - MoinMoin.backends.wiki_group tests
4
 
 
5
 
@copyright: 2003-2004 by Juergen Hermann <jh@web.de>,
6
 
            2007 by MoinMoin:ThomasWaldmann
7
 
            2008 by MoinMoin:MelitaMihaljevic
8
 
            2009 by MoinMoin:DmitrijsMilajevs
9
 
@license: GNU GPL, see COPYING for details.
10
 
"""
11
 
 
12
 
from py.test import raises
13
 
import re, shutil
14
 
 
15
 
from MoinMoin.datastruct.backends._tests import GroupsBackendTest
16
 
from MoinMoin.datastruct import WikiGroups
17
 
from MoinMoin import Page, security
18
 
from MoinMoin.PageEditor import PageEditor
19
 
from MoinMoin.user import User
20
 
from MoinMoin._tests import append_page, become_trusted, create_page, create_random_string_list, nuke_page, nuke_user, wikiconfig
21
 
 
22
 
 
23
 
class TestWikiGroupBackend(GroupsBackendTest):
24
 
 
25
 
    # Suppose that default configuration for the groups is used which
26
 
    # is WikiGroups backend.
27
 
 
28
 
    def setup_class(self):
29
 
        become_trusted(self.request)
30
 
 
31
 
        for group, members in self.test_groups.iteritems():
32
 
            page_text = ' * %s' % '\n * '.join(members)
33
 
            create_page(self.request, group, page_text)
34
 
 
35
 
    def teardown_class(self):
36
 
        become_trusted(self.request)
37
 
 
38
 
        for group in self.test_groups:
39
 
            nuke_page(self.request, group)
40
 
 
41
 
    def test_rename_group_page(self):
42
 
        """
43
 
        Tests if the groups cache is refreshed after renaming a Group page.
44
 
        """
45
 
        request = self.request
46
 
        become_trusted(request)
47
 
 
48
 
        page = create_page(request, u'SomeGroup', u" * ExampleUser")
49
 
        page.renamePage('AnotherGroup')
50
 
 
51
 
        result = u'ExampleUser' in request.groups[u'AnotherGroup']
52
 
        nuke_page(request, u'AnotherGroup')
53
 
 
54
 
        assert result is True
55
 
 
56
 
    def test_copy_group_page(self):
57
 
        """
58
 
        Tests if the groups cache is refreshed after copying a Group page.
59
 
        """
60
 
        request = self.request
61
 
        become_trusted(request)
62
 
 
63
 
        page = create_page(request, u'SomeGroup', u" * ExampleUser")
64
 
        page.copyPage(u'SomeOtherGroup')
65
 
 
66
 
        result = u'ExampleUser' in request.groups[u'SomeOtherGroup']
67
 
 
68
 
        nuke_page(request, u'OtherGroup')
69
 
        nuke_page(request, u'SomeGroup')
70
 
 
71
 
        assert result is True
72
 
 
73
 
    def test_appending_group_page(self):
74
 
        """
75
 
        Test scalability by appending a name to a large list of group members.
76
 
        """
77
 
        request = self.request
78
 
        become_trusted(request)
79
 
 
80
 
        # long list of users
81
 
        page_content = [u" * %s" % member for member in create_random_string_list(length=15, count=1234)]
82
 
        test_user = create_random_string_list(length=15, count=1)[0]
83
 
        create_page(request, u'UserGroup', "\n".join(page_content))
84
 
        append_page(request, u'UserGroup', u' * %s' % test_user)
85
 
        result = test_user in request.groups['UserGroup']
86
 
        nuke_page(request, u'UserGroup')
87
 
 
88
 
        assert result
89
 
 
90
 
    def test_user_addition_to_group_page(self):
91
 
        """
92
 
        Test addition of a username to a large list of group members.
93
 
        """
94
 
        request = self.request
95
 
        become_trusted(request)
96
 
 
97
 
        # long list of users
98
 
        page_content = [u" * %s" % member for member in create_random_string_list()]
99
 
        create_page(request, u'UserGroup', "\n".join(page_content))
100
 
 
101
 
        new_user = create_random_string_list(length=15, count=1)[0]
102
 
        append_page(request, u'UserGroup', u' * %s' % new_user)
103
 
        user = User(request, name=new_user)
104
 
        if not user.exists():
105
 
            User(request, name=new_user, password=new_user).save()
106
 
 
107
 
        result = new_user in request.groups[u'UserGroup']
108
 
        nuke_page(request, u'UserGroup')
109
 
        nuke_user(request, new_user)
110
 
 
111
 
        assert result
112
 
 
113
 
    def test_member_removed_from_group_page(self):
114
 
        """
115
 
        Tests appending a member to a large list of group members and
116
 
        recreating the page without the member.
117
 
        """
118
 
        request = self.request
119
 
        become_trusted(request)
120
 
 
121
 
        # long list of users
122
 
        page_content = [u" * %s" % member for member in create_random_string_list()]
123
 
        page_content = "\n".join(page_content)
124
 
        create_page(request, u'UserGroup', page_content)
125
 
 
126
 
        test_user = create_random_string_list(length=15, count=1)[0]
127
 
        page = append_page(request, u'UserGroup', u' * %s' % test_user)
128
 
 
129
 
        # saves the text without test_user
130
 
        page.saveText(page_content, 0)
131
 
        result = test_user in request.groups[u'UserGroup']
132
 
        nuke_page(request, u'UserGroup')
133
 
 
134
 
        assert not result
135
 
 
136
 
    def test_group_page_user_addition_trivial_change(self):
137
 
        """
138
 
        Test addition of a user to a group page by trivial change.
139
 
        """
140
 
        request = self.request
141
 
        become_trusted(request)
142
 
 
143
 
        test_user = create_random_string_list(length=15, count=1)[0]
144
 
        member = u" * %s\n" % test_user
145
 
        page = create_page(request, u'UserGroup', member)
146
 
 
147
 
        # next member saved  as trivial change
148
 
        test_user = create_random_string_list(length=15, count=1)[0]
149
 
        member = u" * %s\n" % test_user
150
 
        page.saveText(member, 0, trivial=1)
151
 
 
152
 
        result = test_user in request.groups[u'UserGroup']
153
 
 
154
 
        nuke_page(request, u'UserGroup')
155
 
 
156
 
        assert result
157
 
 
158
 
    def test_wiki_backend_page_acl_append_page(self):
159
 
        """
160
 
        Test if the wiki group backend works with acl code.
161
 
        First check acl rights of a user that is not a member of group
162
 
        then add user member to a page group and check acl rights
163
 
        """
164
 
        request = self.request
165
 
        become_trusted(request)
166
 
 
167
 
        create_page(request, u'NewGroup', u" * ExampleUser")
168
 
 
169
 
        acl_rights = ["NewGroup:read,write"]
170
 
        acl = security.AccessControlList(request.cfg, acl_rights)
171
 
 
172
 
        has_rights_before = acl.may(request, u"AnotherUser", "read")
173
 
 
174
 
        # update page - add AnotherUser to a page group NewGroup
175
 
        append_page(request, u'NewGroup', u" * AnotherUser")
176
 
 
177
 
        has_rights_after = acl.may(request, u"AnotherUser", "read")
178
 
 
179
 
        nuke_page(request, u'NewGroup')
180
 
 
181
 
        assert not has_rights_before, 'AnotherUser has no read rights because in the beginning he is not a member of a group page NewGroup'
182
 
        assert has_rights_after, 'AnotherUser must have read rights because after appendage he is member of NewGroup'
183
 
 
184
 
coverage_modules = ['MoinMoin.datastruct.backends.wiki_groups']
185