1# -*- coding: iso-8859-1 -*-
2"""
3MoinMoin - 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
12from py.test import raises
13import re, shutil
14
15from MoinMoin.datastruct.backends._tests import GroupsBackendTest
16from MoinMoin.datastruct import WikiGroups
17from MoinMoin import Page, security
18from MoinMoin.PageEditor import PageEditor
19from MoinMoin.user import User
20from MoinMoin._tests import append_page, become_trusted, create_page, create_random_string_list, nuke_page, nuke_user, wikiconfig
21
22
23class 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    def test_simple_group_page(self):
185        """
186        Tests if a simple group page is evaluated correctly.
187        """
188        request = self.request
189        become_trusted(request)
190        group_name = u'SimpleGroup'
191        page_text = u"""\
192 * FirstUser
193 * SecondUser
194 * LastUser"""
195        page = create_page(request, group_name, page_text)
196        group_members = set(request.groups[group_name])
197        assert group_members == set([u'FirstUser', u'SecondUser', u'LastUser'])
198        nuke_page(request, group_name)
199
200    def test_complex_group_page(self):
201        """
202        Tests if a complex group page is evaluated correctly.
203        """
204        request = self.request
205        become_trusted(request)
206        group_name = u'ComplexGroup'
207        page_text = u"""\
208 * FirstUser
209  * any text
210 * SecondUser
211 * LastUser
212  * any text"""
213        page = create_page(request, group_name, page_text)
214        group_members = set(request.groups[group_name])
215        assert group_members == set([u'FirstUser', u'SecondUser', u'LastUser'])
216        nuke_page(request, group_name)
217
218coverage_modules = ['MoinMoin.datastruct.backends.wiki_groups']
219
220