예제 #1
0
 def testWorkflowMenuWithNoTransitionsDisabled(self):
     logout()
     items = self.menu.getMenuItems(self.folder, self.request)
     workflowMenuItem = [
         i for i in items if
         i['extra']['id'] == 'plone-contentmenu-workflow'][0]
     self.assertEqual(workflowMenuItem['action'], '')
예제 #2
0
 def test_not_available(self):
     # Use a non-opened poll
     poll_uid = IUUID(self.p1)
     logout()
     r = self.renderer(assignment=voteportlet.Assignment(header='Polls',
                                                         poll=poll_uid))
     self.assertEqual(False, r.available)
    def test_percentage_vote_report(self):
        poll = self.p3
        # Vote as logged user
        options = 2
        voted = poll.setVote(options, self.request)
        self.assertTrue(voted)

        total = poll.total_votes
        self.assertEqual(total, 1)

        results = poll.getResults()
        # One vote
        self.assertEqual(results[options][1], 1)
        # 100%
        self.assertEqual(results[options][2], 1.0)

        logout()
        options = 1
        voted = poll.setVote(options, self.request)
        self.assertTrue(voted)

        total = poll.total_votes
        self.assertEqual(total, 2)

        results = poll.getResults()
        # One vote
        self.assertEqual(results[options][1], 1)
        # 50%
        self.assertEqual(results[options][2], 0.5)
예제 #4
0
    def setUpContent(self):
        login(self.portal, testing.SITE_ADMIN)
        self.project = helpers.create_project(
            self.workspaces, 'project', title=u"Project")
        self.project_admin = helpers.add_activated_student(
            self.people, u"Hörbert M@ier")
        self.project.addManager(self.project_admin.id)
        self.project_admin2 = helpers.add_activated_student(
            self.people, u"Administanator")
        self.project.addManager(self.project_admin2.id)

        self.ws = ws_helpers.create_workspace(self.workspaces,
            "project_workspace_1", title=u"Project-Workspace")
        self.ws_member = helpers.add_activated_student(
            self.people, u"Workspace Member")
        self.ws.addMember(self.ws_member.id)
        self.project.add_workspace(self.ws)

        self.ws2 = ws_helpers.create_workspace(self.workspaces,
            "project_workspace_2", title=u"Project-Workspace")
        self.ws_member2 = helpers.add_activated_student(
            self.people, u"Another Workspace Member")
        self.ws2.addMember(self.ws_member2.id)
        self.project.add_workspace(self.ws2)
        logout()
예제 #5
0
 def test_available_anonymous(self):
     # Use a opened poll
     poll_uid = IUUID(self.p3)
     r = self.renderer(assignment=voteportlet.Assignment(header='Polls',
                                                         poll=poll_uid))
     logout()
     self.assertEqual(True, r.available)
예제 #6
0
    def testSourcePermissionDenied(self):
        from z3c.form.browser.text import TextWidget
        from zope.interface import implementer
        from zope.interface import Interface
        from zope.schema import Choice
        from zope.schema.interfaces import ISource

        @implementer(ISource)
        class DummyCatalogSource(object):
            def search_catalog(self, query):
                querytext = query['SearchableText']['query']
                return [Mock(id=querytext)]

        widget = TextWidget(self.request)
        widget.context = self.portal
        widget.field = Choice(source=DummyCatalogSource())
        widget.field.interface = Interface

        from plone.app.content.browser.vocabulary import SourceView
        view = SourceView(widget, self.request)
        query = {
            'criteria': [
                {
                    'i': 'SearchableText',
                    'o': 'plone.app.querystring.operation.string.is',
                    'v': 'foo'
                }
            ]
        }
        self.request.form.update({
            'query': json.dumps(query),
        })
        logout()
        data = json.loads(view())
        self.assertEquals(data['error'], 'Vocabulary lookup not allowed.')
    def test_anonymous_can_not_add_comments_if_discussion_is_not_allowed(self):
        """Make sure that anonymous users can't post comments if anonymous
           comments are disabled.
        """

        # Anonymous comments are disabled by default

        logout()

        def make_request(form={}):
            request = TestRequest()
            request.form.update(form)
            alsoProvides(request, IFormLayer)
            alsoProvides(request, IAttributeAnnotatable)
            return request

        provideAdapter(adapts=(Interface, IBrowserRequest),
                       provides=Interface,
                       factory=CommentForm,
                       name=u"comment-form")

        request = make_request(form={'form.widgets.text': u'bar'})

        commentForm = getMultiAdapter((self.context, request),
                                      name=u"comment-form")
        commentForm.update()
        data, errors = commentForm.extractData()  # pylint: disable-msg=W0612

        self.assertEqual(len(errors), 0)
        self.assertRaises(
            Unauthorized,
            commentForm.handleComment,
            commentForm,
            "foo"
        )
예제 #8
0
 def tearDown(self):
     for s in self.services:
         s.setAllowManualUncertainty(False)
         s.setUncertainties([])
         s.setPrecisionFromUncertainty(False)
     logout()
     super(TestManualUncertainty, self).tearDown()
예제 #9
0
def createMembers(portal, userdefs, log_in=True):
    """Create example members in testing environment

    example_userdefs = [
            {'user': '******', 'roles': ('Member', 'Manager'), 'groups': ()},
            {'user': '******', 'roles': ('Member', ), 'groups': ()},
            {'user': '******', 'roles': (), 'groups': ('contributeurs',)},
            {'user': '******', 'roles': (), 'groups': ('animateurs',)},
            ]
    """
    if log_in:
        setRoles(portal, TEST_USER_ID, ["Manager"])
        login(portal, TEST_USER_NAME)

    pas = portal.acl_users
    gtool = portal.portal_groups
    for userinfo in userdefs:
        username = userinfo["user"]
        addMember(pas, username, roles=userinfo["roles"])
        member = portal.portal_membership.getMemberById(username)
        member.setMemberProperties({"email": "*****@*****.**" % username, "fullname": username.title()})
        for groupname in userinfo["groups"]:
            group = gtool.getGroupById(groupname)
            group.addMember(username)

    if log_in:
        setRoles(portal, TEST_USER_ID, ["Member"])
        logout()
예제 #10
0
 def setUp(self):
     portal = self.layer['portal']
     self.tp_catalog = portal.tablepage_catalog
     login(portal, TEST_USER_NAME)
     portal.invokeFactory(type_name='TablePage', id='table_page', title="The Table Document")
     tp = portal.table_page
     tp.edit(pageColumns=[{'id': 'foo_field', 'label': 'Foo field', 'description': '',
                           'type': 'String', 'vocabulary': '', 'options': []},
                           ],
             batchSize=10)
     tp.edit(searchConfig=[{'id': 'foo_field', 'label': '', 'description': '',
                            'additionalConfiguration': ['SearchableText']}])
     self.tp = tp
     self.storage = IDataStorage(tp)
     self._addRows(35)
     # now adding another tablepage: this must be always ignored by searches
     portal.invokeFactory(type_name='TablePage', id='table_page2', title="Another Table Document")
     portal.table_page2.edit(pageColumns=[{'id': 'foo_field', 'label': 'Foo field', 'description': '',
                                           'type': 'String', 'vocabulary': '', 'options': []},
                                           ],
                                           batchSize=10)
     storage2 = IDataStorage(portal.table_page2)
     storage2.add({'__label__': 'A Label', '__uuid__': 'l2l2l2'})
     storage2.add({'foo_field': 'aa001', '__uuid__': '010'})
     portal.portal_workflow.doActionFor(tp, 'publish')
     self.tp_catalog.clearFindAndRebuild()
     logout()
예제 #11
0
 def test_file_type(self):
     self.link.remoteUrl = 'file:///some/file/on/your/system'
     view = self._get_link_redirect_view(self.link)
     self._publish(self.link)
     logout()
     self.assertTrue(view())
     self._assert_redirect(self.link.remoteUrl)
예제 #12
0
 def test_anonymous_allowed_to_view(self):
     ''' Anonymous can view a opened poll '''
     logout()
     utility = queryUtility(IPolls, name='collective.polls')
     # Opened Poll, member can view
     poll = self.subfolder['p5']
     self.assertTrue(utility.allowed_to_view(poll))
예제 #13
0
 def test_anonymous_not_allowed_to_view(self):
     ''' Anonymous cannot view a private poll '''
     logout()
     utility = queryUtility(IPolls, name='collective.polls')
     # Opened Poll, member can view
     poll = self.subfolder['p6']
     self.assertFalse(utility.allowed_to_view(poll))
    def test_delete_confirmation_if_locked(self):
        folder = self.portal['f1']
        lockable = ILockable.providedBy(folder)

        form = getMultiAdapter(
            (folder, self.request), name='delete_confirmation')
        form.update()

        self.assertFalse(form.is_locked)

        if lockable:
            lockable.lock()

        form = getMultiAdapter(
            (folder, self.request), name='delete_confirmation')
        form.update()

        self.assertFalse(form.is_locked)

        # After switching the user it should not be possible to delete the
        # object. Of course this is only possible if our context provides
        # ILockable interface.
        if lockable:
            logout()
            login(self.portal, 'editor')

            form = getMultiAdapter(
                (folder, self.request), name='delete_confirmation')
            form.update()
            self.assertTrue(form.is_locked)

            logout()
            login(self.portal, TEST_USER_NAME)

            ILockable(folder).unlock()
예제 #15
0
    def test_project_info_navigation_anonymous(self):
        pat.logout()
        open(self.driver, self.project.absolute_url())
        nav_links = self.find_elements(By.CSS_SELECTOR, ".content-views>li>a")
        nav_link_texts = [x.text for x in nav_links]

        self.assertListEqual(nav_link_texts, [u'Information', u'Conversation'])
예제 #16
0
    def test_results(self):
        # set standard workflow for News Items
        wt = self.portal['portal_workflow']
        wt.setChainForPortalTypes(['News Item'], 'simple_publication_workflow')
        # create some testing content and add it to the tile
        with api.env.adopt_roles(['Manager']):
            folder = api.content.create(self.portal, 'Folder', id='test')
        for i in range(1, 10):
            obj = api.content.create(folder, 'News Item', id=str(i))
            self.tile.populate_with_object(obj)

        # tile should list the first 5 objects
        results = self.tile.results()
        self.assertEqual(len(results), 5)
        for i in range(1, 6):
            self.assertIn(folder[str(i)], results)

        # for an anonymous user, no content is returned
        logout()
        results = self.tile.results()
        self.assertEqual(len(results), 0)

        # for the test user, the first 5 objects should be still there
        login(self.portal, TEST_USER_NAME)
        results = self.tile.results()
        self.assertEqual(len(results), 5)
        for i in range(1, 6):
            self.assertIn(folder[str(i)], results)

        # delete one object; it should be removed from the tile also
        api.content.delete(folder['1'])
        results = self.tile.results()
        self.assertEqual(len(results), 5)
        for i in range(2, 7):
            self.assertIn(folder[str(i)], results)
예제 #17
0
    def setUpPloneSite(self, portal):
        login(portal.aq_parent, SITE_OWNER_NAME)

        wf = getToolByName(portal, 'portal_workflow')
        wf.setDefaultChain('plone_workflow')
        setupPortalContent(portal)

        # make sure we have folder_listing as a template
        portal.getTypeInfo().manage_changeProperties(
            view_methods=['folder_listing'],
            default_view='folder_listing')

        applyProfile(portal, 'bika.lims:default')

        # Add some test users
        for role in ('LabManager',
                     'LabClerk',
                     'Analyst',
                     'Verifier',
                     'Sampler',
                     'Preserver',
                     'Publisher',
                     'Member',
                     'Reviewer',
                     'RegulatoryInspector'):
            for user_nr in range(2):
                if user_nr == 0:
                    username = "******" % (role.lower())
                else:
                    username = "******" % (role.lower(), user_nr)
                try:
                    member = portal.portal_registration.addMember(
                        username,
                        username,
                        properties={
                            'username': username,
                            'email': username + "@example.com",
                            'fullname': username}
                    )
                    # Add user to all specified groups
                    group_id = role + "s"
                    group = portal.portal_groups.getGroupById(group_id)
                    if group:
                        group.addMember(username)
                    # Add user to all specified roles
                    member._addRole(role)
                    # If user is in LabManagers, add Owner local role on clients folder
                    if role == 'LabManager':
                        portal.clients.manage_setLocalRoles(username,
                                                            ['Owner', ])
                except ValueError:
                    pass  # user exists

        # Force the test browser to show the site always in 'en'
        ltool = portal.portal_languages
        ltool.manage_setLanguageSettings('en', ['en'],
                                         setUseCombinedLanguageCodes=False,
                                         startNeutral=True)

        logout()
 def test_collection_templates(self):
     data = getData('image.png')
     # add an image that will be listed by the collection
     self.portal.invokeFactory("Image",
                          "image",
                          title="Image example",
                          image=data)
     # Search for images
     query = [{
         'i': 'Type',
         'o': 'plone.app.querystring.operation.string.is',
         'v': 'Image',
     }]
     # set the query and publish the collection
     self.collection.setQuery(query)
     commit()
     logout()
     # open a browser to see if our image is in the results
     browser = Browser(self.layer['app'])
     browser.handleErrors = False
     browser.open(self.collection.absolute_url())
     self.assertTrue("Image example" in browser.contents)
     # open summary_view template
     browser.open('%s/summary_view' % self.collection.absolute_url())
     self.assertTrue("Image example" in browser.contents)
     # open folder_summary_view template
     browser.open('%s/folder_summary_view' % self.collection.absolute_url())
     self.assertTrue("Image example" in browser.contents)
     # open thumbnail_view template
     browser.open('%s/thumbnail_view' % self.collection.absolute_url())
     self.assertTrue("Image example" in browser.contents)
예제 #19
0
    def test_pub_date(self):
        # configure our portal to enable publication date on pages globally on
        # the site
        registry = getUtility(IRegistry)
        settings = registry.forInterface(
            ISiteSchema,
            prefix='plone')

        settings.display_publication_date_in_byline = True

        logout()
        viewlet = self._get_viewlet()

        # publication date should be None as there is not Effective date set
        # for our document yet
        self.assertEqual(viewlet.pub_date(), None)

        # now set effective date for our document
        effective = DateTime()
        self.context.setEffectiveDate(effective)
        self.assertEqual(viewlet.pub_date(), DateTime(effective.ISO8601()))

        # now switch off publication date globally on the site and see if
        # viewlet returns None for publication date
        settings.display_publication_date_in_byline = False
        self.assertEqual(viewlet.pub_date(), None)
예제 #20
0
def export(portal, context, request, url):
    environ_orig = request.environ
    form_orig = request.form.copy()
    other_orig = request.other.copy()
    stdout_orig = request.response.stdout
    stdout = StringIO.StringIO()
    getattr(request, '__annotations__', {}).clear()
    try:
        request.environ['QUERY_STRING'] = urlparse.urlsplit(
            url).query
        request.response.stdout = stdout
        request.processInputs()
        testing.login(portal, testing.TEST_USER_NAME)
        export_view = context.restrictedTraverse('export')
        export_view()
    finally:
        request.response.stdout = stdout_orig
        request.environ.clear()
        request.environ.update(environ_orig)
        request.form.clear()
        request.form.update(form_orig)
        request.other.clear()
        request.other.update(other_orig)
        testing.logout()
    return stdout.getvalue()
예제 #21
0
 def testAnonymous(self):
     logout()
     ctx = IPortletContext(self.folder)
     g = ctx.globalPortletCategories()
     self.assertEqual(len(g), 2)
     self.assertEqual(g[0], ('content_type', 'Folder'))
     self.assertEqual(g[1], ('user', 'Anonymous User'))
 def test_view_protected(self):
     # view can not be accessed by anonymous users
     from AccessControl import Unauthorized
     logout()
     self.assertRaises(Unauthorized,
                       self.portal.restrictedTraverse,
                       '@@quickupload-controlpanel')
    def test_draft_state(self):
        """
        draft content can only be viewed by a team manager and owner
        """
        admin_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertTrue(admin_permissions[VIEW],
                        'Admin cannot view draft content')

        member_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertFalse(member_permissions[VIEW],
                         'Member can view draft content')

        nonmember_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertFalse(nonmember_permissions[VIEW],
                         'Non-member can view draft content')

        logout()
        anon_permissions = api.user.get_permissions(
            obj=self.document,
        )
        self.assertFalse(anon_permissions[VIEW],
                         'Anonymous can view draft content')
    def test_pending_state(self):
        """
        team managers should be able to view pending items,
        team members should not
        """
        api.content.transition(self.document, 'submit')

        admin_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertTrue(admin_permissions[VIEW],
                        'Admin cannot view pending content')

        member_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertFalse(member_permissions[VIEW],
                         'member can view pending content')

        nonmember_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertFalse(nonmember_permissions[VIEW],
                         'nonmember can view pending content')

        logout()
        anon_permissions = api.user.get_permissions(
            obj=self.document,
        )
        self.assertFalse(anon_permissions[VIEW],
                         'Anonymous can view pending content')
    def test_published_state(self):
        """
        all team members should be able to see published content,
        regular plone users should also
        """
        api.content.transition(self.document, 'submit')
        api.content.transition(self.document, 'publish')

        admin_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertTrue(admin_permissions[VIEW],
                        'Admin cannot view published content')

        member_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertTrue(member_permissions[VIEW],
                        'member cannot view published content')

        nonmember_permissions = api.user.get_permissions(
            username='******',
            obj=self.document,
        )
        self.assertTrue(nonmember_permissions[VIEW],
                        'user cannot view workspace content')

        logout()
        anon_permissions = api.user.get_permissions(
            obj=self.document,
        )
        self.assertFalse(anon_permissions[VIEW],
                         'Anonymous can view draft content')
    def test_user_activation(self):
        login(self.portal, testing.SITE_ADMIN)

        members = self.portal['people']

        # create a user:
        member = utilities.add_member_object(members, member_id='member',
            fullname=u"Hörbert M@ier", email="*****@*****.**")

        logout()

        password = '******'
        utilities.add_plone_member(member, password)
        utilities.activate_member_object(member)

        plone_member = self.portal.acl_users.authenticate(member.id, password,
            self.portal.REQUEST)
        self.assertNotEqual(plone_member, None)

        portal_membership = getToolByName(self.portal, 'portal_membership')
        plone_member = portal_membership.getMemberById(member.id)
        self.assertNotEqual(plone_member, None)

        self.assertEqual(unicode(plone_member.getProperty('fullname'), 'utf-8'),
            member.title)
        self.assertEqual(plone_member.getProperty('email'), member.emailAddress)

        login(self.portal, member.id)
    def test_add_anonymous_comment(self):
        self.discussionTool.overrideDiscussionFor(self.portal.doc1, True)

        self.viewlet = CommentsViewlet(self.context, self.request, None, None)

        registry = queryUtility(IRegistry)
        settings = registry.forInterface(IDiscussionSettings, check=False)
        settings.anonymous_comments = True

        # Logout
        logout()

        def make_request(form={}):
            request = TestRequest()
            request.form.update(form)
            alsoProvides(request, IFormLayer)
            alsoProvides(request, IAttributeAnnotatable)
            return request

        provideAdapter(adapts=(Interface, IBrowserRequest),
                       provides=Interface,
                       factory=CommentForm,
                       name=u"comment-form")

        # Post an anonymous comment and provide a name
        request = make_request(form={'form.widgets.name': u'john doe',
                                     'form.widgets.text': u'bar'})

        commentForm = getMultiAdapter((self.context, request),
                                      name=u"comment-form")
        commentForm.update()
        data, errors = commentForm.extractData()  # pylint: disable-msg=W0612

        self.assertEqual(len(errors), 0)
        self.assertFalse(commentForm.handleComment(commentForm, "action"))
    def test_view_comments(self):
        """Make sure published comments can be viewed by everyone.
        """
        # Owner is allowed
        # self.login(default_user)
        # self.assertTrue(checkPerm(View, self.doc))
        # Member is allowed
        login(self.portal, TEST_USER_NAME)
        workflow = self.portal.portal_workflow
        workflow.doActionFor(self.doc, 'publish')

        login(self.portal, 'member')
        self.assertTrue(checkPerm(View, self.comment))
        # Reviewer is allowed
        login(self.portal, 'reviewer')
        self.assertTrue(checkPerm(View, self.comment))
        # Anonymous is allowed
        logout()
        self.assertTrue(checkPerm(View, self.comment))
        # Editor is allowed
        login(self.portal, 'editor')
        self.assertTrue(checkPerm(View, self.comment))
        # Reader is allowed
        login(self.portal, 'reader')
        self.assertTrue(checkPerm(View, self.comment))
예제 #29
0
 def test_migrate_view_protected(self):
     """
     test if the view is protected
     """
     from AccessControl import Unauthorized
     logout()
     self.assertRaises(Unauthorized, self.portal.restrictedTraverse, '@@migrate-types')
    def setUpContent(self):
        login(self.portal, testing.SITE_ADMIN)

        self.ws = ws_helpers.create_workspace(self.workspaces,
            "test-workspace", title=u"Test Workspace")

        self.links = []
        self.links_by_group = {}

        for i in range(1, 4):
            group_label = u"Group {0}".format(i)
            group_handle = add_group(self.ws, group_label)
            link_id = "link-{0}".format(i)
            link_title = u"Link {0}".format(i)
            self.ws.invokeFactory('RichLink', link_id, title=link_title,
                                  url="www.ixds.com", rmGroup=group_handle)
            self.links.append(self.ws[link_id])
            self.links_by_group[group_handle] = self.ws[link_id]

        link_id = "link-without-group"
        self.ws.invokeFactory('RichLink', link_id, title="Link without Group",
                              url="www.ixds.com")
        self.misc_link = self.ws[link_id]
        self.links.append(self.misc_link)
        self.links_by_group['Miscellaneous'] = self.misc_link

        add_group(self.ws, u"Empty Group")

        logout()
예제 #31
0
 def test_getUserId_anonymous(self):
     logout()
     self.assertEqual(None, getCurrentUserId())
 def test_controlpanel_view_is_protected(self):
     from AccessControl import Unauthorized
     logout()
     with self.assertRaises(Unauthorized):
         self.portal.restrictedTraverse('@@global_statusmessage_config')
예제 #33
0
 def logout(self):
     return logout()
예제 #34
0
 def tearDown(self):
     logout()
     super(TestShowPartitions, self).tearDown()
예제 #35
0
 def reject_poll(self, poll):
     login(self.portal, TEST_USER_NAME)
     setRoles(self.portal, TEST_USER_ID, ['Manager'])
     self.wt.doActionFor(poll, 'reject')
     setRoles(self.portal, TEST_USER_ID, ['Member'])
     logout()
 def test_controlpanel_view_is_protected(self):
     from AccessControl import Unauthorized
     logout()
     with self.assertRaises(Unauthorized):
         self.portal.restrictedTraverse('@@texttospeech-settings')
예제 #37
0
 def test__footer_controlpanel_view_protected(self):
     """The control panel view should be protected"""
     portal = self.layer['portal']
     logout()
     self.assertRaises(Unauthorized, portal.restrictedTraverse,
                       '@@footer-controlpanel')
예제 #38
0
 def test_mls_controlpanel_view_protected(self):
     """Test that the MLS configuration view needs authentication."""
     from AccessControl import Unauthorized
     logout()
     self.assertRaises(Unauthorized, self.portal.restrictedTraverse,
                       '@@mls-controlpanel')
예제 #39
0
    def setUpPloneSite(self, portal):
        """Setup the Plone site with some groups.

        Create some standard groups and subgroups,
        and same for content groups, so we can compare.
        Let the groups ids start with the same character,
        so that we can check that both types can be found.
        """
        applyProfile(portal, "collective.contentgroups.tests:testing")
        # Create some standard groups.
        subcasual = api.group.create(groupname="subcasual", title="Sub Casual")
        casual = api.group.create(groupname="casual",
                                  title="Casual",
                                  roles=["Reader"],
                                  groups=["subcasual"])
        # Create some content groups.  We need to be logged in for this.
        # Take over some lines from plone.app.contenttypes.testing
        # for creating a site owner and logging in.  I expected that the
        # site owner already existed, but apparently not.
        portal.acl_users.userFolderAddUser(SITE_OWNER_NAME,
                                           SITE_OWNER_PASSWORD, ["Manager"],
                                           [])
        login(portal, SITE_OWNER_NAME)
        content1 = api.content.create(container=portal,
                                      type="Group",
                                      id="content1",
                                      title="Content 1")
        content2 = api.content.create(container=portal,
                                      type="Group",
                                      id="content2",
                                      title="Content 2")
        # Create sub content groups.
        # Note that ids and title are different so that we can test the sort order.
        sub2a = api.content.create(container=portal,
                                   type="Group",
                                   id="sub2a",
                                   title="2A Sub Content")
        sub2b = api.content.create(container=portal,
                                   type="Group",
                                   id="sub2b",
                                   title="2B Sub Content")
        content_sub_of_standard = api.content.create(
            container=portal,
            type="Group",
            id="content_sub_of_standard",
            title="Content Sub of Standard",
        )
        content_sub_of_standard.users = ""
        logout()
        # Add the sub groups to their parent groups.
        api.group.add_user(group=casual, user=subcasual)
        # Ah, yes, we don't support this for content groups, because you have to go
        # through the content UI
        content2.users = "sub2a\nsub2b"
        # Let's also create a standard sub group in a content group:
        standard_sub_of_content = api.group.create(
            groupname="standard_sub_of_content",
            title="Standard Sub of Content 1",
            roles=["Reader"],
        )
        content1.users = "standard_sub_of_content"
        # and a content sub group in a standard group.
        api.group.add_user(group=casual, user=content_sub_of_standard)
        # Create some standard users and add them to groups.
        ann = api.user.create(
            email="*****@*****.**",
            username="******",
            password="******",
            properties={"title": "Ann Casual"},
        )
        api.group.add_user(group=casual, user=ann)
        bert = api.user.create(
            email="*****@*****.**",
            username="******",
            password="******",
            properties={"title": "Bert Sub Casual"},
        )
        api.group.add_user(group=subcasual, user=bert)
        corey = api.user.create(
            email="*****@*****.**",
            username="******",
            password="******",
            properties={"title": "Corey Content 1"},
        )
        content1.users += "\n{0}".format(corey.getUserId())
        donna = api.user.create(
            email="*****@*****.**",
            username="******",
            password="******",
            properties={"title": "Donna Content 2"},
        )
        content2.users += "\n{0}".format(donna.getUserId())
        eddy = api.user.create(
            email="*****@*****.**",
            username="******",
            password="******",
            properties={"title": "Eddy Sub 2A"},
        )
        sub2a.users = eddy.getUserId()
        fiona = api.user.create(
            email="*****@*****.**",
            username="******",
            password="******",
            properties={"title": "Fiona Sub 2B"},
        )
        sub2b.users = fiona.getUserId()
        # Add one user who is in all groups.
        general = api.user.create(
            email="*****@*****.**",
            username="******",
            password="******",
            properties={"title": "General"},
        )
        for group in (casual, subcasual, standard_sub_of_content):
            api.group.add_user(group=group, user=general)
        for group in (content1, content2, sub2a, sub2b,
                      content_sub_of_standard):
            group.users += "\n{0}".format(general.getUserId())
        # Add one user who is in all SUB groups.
        sub = api.user.create(
            email="*****@*****.**",
            username="******",
            password="******",
            properties={"title": "Sub"},
        )
        for group in (subcasual, standard_sub_of_content):
            api.group.add_user(group=group, user=sub)
        for group in (sub2a, sub2b, content_sub_of_standard):
            group.users += "\n{0}".format(sub.getUserId())
예제 #40
0
 def anon_permissions(self, permission):
     logout()
     permissions = api.user.get_permissions(obj=self.document, )
     return permissions[permission]
예제 #41
0
 def test_controlpanel_view_is_protected(self):
     from AccessControl import Unauthorized
     logout()
     self.assertRaises(Unauthorized, self.portal.restrictedTraverse,
                       '@@imagecropping-settings')
예제 #42
0
    def test_permission_aware_search(self):
        """ """
        items = self.load_contents()
        practitioner_user = api.user.get(username=PRACTITIONER_USER_NAME)

        org1_url = items[0]

        org_id = org1_url.split("/")[-1]
        brain = api.portal.get_tool("portal_catalog")(
            portal_type="Organization", id=[org_id]
        )
        organization = brain[0].getObject()
        api.user.grant_roles(
            user=practitioner_user, obj=organization, roles=["Practitioner"]
        )

        patient1_url = items[3]
        patient_id = patient1_url.split("/")[-1]

        brain = api.portal.get_tool("portal_catalog")(
            portal_type="Patient", id=[patient_id]
        )
        patient = brain[0].getObject()

        patient_user = api.user.get(username=PATIENT_USER_NAME)
        api.user.grant_roles(user=patient_user, obj=patient, roles=["Patient"])
        api.user.grant_roles(
            user=patient_user, obj=organization, roles=["OrganizationMember"]
        )

        patient2_url = items[-1]
        patient_id = patient2_url.split("/")[-1]

        brain = api.portal.get_tool("portal_catalog")(
            portal_type="Patient", id=[patient_id]
        )
        patient2 = brain[0].getObject()
        patient_user2 = api.user.get(username=PATIENT_USER2_NAME)
        api.user.grant_roles(user=patient_user2, obj=patient2, roles=["Patient"])
        api.user.grant_roles(
            user=patient_user2, obj=organization, roles=["OrganizationMember"]
        )
        # Update Index
        organization.reindexObjectSecurity()
        self.commit()
        time.sleep(1)
        logout()
        params = [("_lastUpdated", "2010-05-28T05:35:56+01:00")]
        search_factory = self.get_factory("Organization", unrestricted=False)
        with api.env.adopt_user(username=PATIENT_USER_NAME):
            bundle = search_factory(params)
            # patient one should have access on his own organization
            self.assertEqual(len(bundle.entry), 1)
            self.assertEqual(bundle.entry[0].resource.id, "f001")

            params = [("gender", "male")]
            search_factory = self.get_factory("Patient", unrestricted=False)
            bundle = search_factory(params)

            # Although First organization have to two patients,
            # but should access it's own.
            self.assertEqual(len(bundle.entry), 1)
            self.assertEqual(
                bundle.entry[0].resource.id, "19c5245f-89a8-49f8-b244-666b32adb92e"
            )

            params = [("status", "ready")]
            search_factory = self.get_factory("Task", unrestricted=False)
            bundle = search_factory(params)
            self.assertEqual(len(bundle.entry), 2)

        with api.env.adopt_user(username=PRACTITIONER_USER_NAME):
            params = [("active", "true")]
            search_factory = self.get_factory("Organization", unrestricted=False)
            bundle = search_factory(params)
            # still single organization
            self.assertEqual(len(bundle.entry), 1)

            params = [("gender", "male")]
            search_factory = self.get_factory("Patient", unrestricted=False)
            bundle = search_factory(params)

            # First organization have to two patients,
            # should access both.
            self.assertEqual(len(bundle.entry), 2)

            params = [("status:not", "rejected")]
            search_factory = self.get_factory("Task", unrestricted=False)
            bundle = search_factory(params)

            self.assertEqual(len(bundle.entry), 3)

        with api.env.adopt_user(username=PATIENT_USER2_NAME):
            params = [("active", "true")]
            search_factory = self.get_factory("Organization", unrestricted=False)
            bundle = search_factory(params)
            # still single organization
            self.assertEqual(len(bundle.entry), 1)

            params = [("gender", "male")]
            search_factory = self.get_factory("Patient", unrestricted=False)
            bundle = search_factory(params)

            self.assertEqual(len(bundle.entry), 1)
            self.assertNotEqual(
                bundle.entry[0].resource.id, "19c5245f-89a8-49f8-b244-666b32adb92e"
            )
 def test_audit_log_view_is_protected(self):
     from AccessControl import Unauthorized
     logout()
     with self.assertRaises(Unauthorized):
         self.portal.restrictedTraverse('@@fingerpointing-audit-log')
 def tearDown(self):
     logout()
     super(Test_LIMS2001, self).tearDown()
예제 #45
0
 def test_comment_on_private_content_not_visible_to_world(self):
     logout()
     self.assertFalse(checkPerm(View, self.comment))
 def testLogin(self):
     logout()
     login(self.portal, IMembraneUserAuth(self.member).getUserId())
예제 #47
0
 def test_can_reply(self):
     # Portal owner can reply
     self.assertTrue(self.viewlet.can_reply())
     logout()
     # Anonymous users can not reply
     self.assertFalse(self.viewlet.can_reply())
예제 #48
0
 def logout(self):
     """
     helper method to avoid importing the p.a.testing logout method
     """
     logout()
예제 #49
0
 def test_controlpanel_view_is_protected(self):
     from AccessControl import Unauthorized
     logout()
     with self.assertRaises(Unauthorized):
         self.portal.restrictedTraverse('@@prefs_keywords_view')
예제 #50
0
 def test_is_anonymous(self):
     self.assertFalse(self.viewlet.is_anonymous())
     logout()
     self.assertTrue(self.viewlet.is_anonymous())
예제 #51
0
 def test_controlpanel_view_is_protected(self):
     from AccessControl import Unauthorized
     from plone.app.testing import logout
     logout()
     with self.assertRaises(Unauthorized):
         self.portal.restrictedTraverse('@@amp-settings')
예제 #52
0
class SimpleTestLayer(PloneSandboxLayer):
    """Setup Plone with installed AddOn only
    """
    defaultBases = (
        BIKA_LIMS_FUNCTIONAL_TESTING,
        PLONE_FIXTURE,
    )

    def setUpZope(self, app, configurationContext):
        super(SimpleTestLayer, self).setUpZope(app, configurationContext)

        # Load ZCML
        # import senaite.api
        import bika.lims

        # self.loadZCML(package=senaite.api)
        self.loadZCML(package=bika.lims)

        # Install product and call its initialize() function
        z2.installProduct(app, 'senaite.addon')

    def setUpPloneSite(self, portal):
        super(SimpleTestLayer, self).setUpPloneSite(portal)

        # Apply Setup Profile (portal_quickinstaller)
        applyProfile(portal, 'bika.lims:default')
        # applyProfile(portal, 'senaite.api:default')

        login(portal.aq_parent, SITE_OWNER_NAME)

        # Add some test users
        for role in ('LabManager', 'LabClerk', 'Analyst', 'Verifier',
                     'Sampler', 'Preserver', 'Publisher', 'Member', 'Reviewer',
                     'RegulatoryInspector'):
            for user_nr in range(2):
                if user_nr == 0:
                    username = "******" % (role.lower())
                else:
                    username = "******" % (role.lower(), user_nr)
                try:
                    member = portal.portal_registration.addMember(
                        username,
                        username,
                        properties={
                            'username': username,
                            'email': username + "@example.com",
                            'fullname': username
                        })
                    # Add user to all specified groups
                    group_id = role + "s"
                    group = portal.portal_groups.getGroupById(group_id)
                    if group:
                        group.addMember(username)
                    # Add user to all specified roles
                    member._addRole(role)
                    # If user is in LabManagers, add Owner local role on clients folder
                    if role == 'LabManager':
                        portal.clients.manage_setLocalRoles(
                            username, [
                                'Owner',
                            ])
                except ValueError:
                    pass  # user exists

    logout()
예제 #53
0
 def test_get_restricted_translation_for_anonymous(self):
     logout()
     restricted_translations = \
         ITranslationManager(self.a_ca).get_restricted_translations()
     self.assertEqual(restricted_translations, {})
예제 #54
0
 def logout(self):
     """Log out, i.e. become anonymous."""
     testing.logout()
예제 #55
0
 def test_disallow_sendto(self):
     logout()
     portal = self.layer['portal']
     self.assertFalse(checkPerm('Allow sendto', portal))
예제 #56
0
 def setUp(self):
     self.portal = self.layer['portal']
     logout()
예제 #57
0
 def logout(self):
     logout()
예제 #58
0
    def test_community_creation_closed(self):
        nom = u'community-test'
        description = 'Blabla'
        image = None
        community_type = 'Closed'
        twitter_hashtag = 'helou'

        login(self.portal, 'ulearn.testuser1')

        self.portal.invokeFactory('ulearn.community',
                                  'community-test',
                                  title=nom,
                                  description=description,
                                  image=image,
                                  community_type=community_type,
                                  twitter_hashtag=twitter_hashtag)

        community = self.portal['community-test']

        logout()

        # Test for the acl registry
        soup = get_soup('communities_acl', self.portal)
        # By the gwuuid
        records = [
            r for r in soup.query(Eq('gwuuid',
                                     IGWUUID(community).get()))
        ]
        self.assertEqual(len(records), 1)
        self.assertEqual(records[0].attrs.get('gwuuid', ''),
                         IGWUUID(community).get())
        self.assertEqual(records[0].attrs.get('path', ''),
                         '/'.join(community.getPhysicalPath()))
        self.assertEqual(records[0].attrs.get('hash', ''),
                         sha1(community.absolute_url()).hexdigest())
        self.assertEqual(
            records[0].attrs.get('acl', '').get('users', [])[0]['role'],
            u'owner')
        self.assertEqual(
            records[0].attrs.get('acl', '').get('users', [])[0]['id'],
            u'ulearn.testuser1')

        # Test for internal objects
        self.assertEqual(community.objectIds(),
                         ['documents', 'events', 'discussion'])

        # Test for photo folder
        self.assertEqual(community['documents'].objectIds(), [
            'media',
        ])

        # Test for subscribed users
        self.assertTrue(
            u'ulearn.testuser1' in self.get_max_subscribed_users(community))

        # Test for Plone permissions/local roles
        self.assertTrue('Reader' not in community.get_local_roles_for_userid(
            userid='AuthenticatedUsers'))
        self.assertTrue('Editor' in community.get_local_roles_for_userid(
            userid='ulearn.testuser1'))
        self.assertTrue('Owner' in community.get_local_roles_for_userid(
            userid='ulearn.testuser1'))
        self.assertTrue('Reader' in community.get_local_roles_for_userid(
            userid='ulearn.testuser1'))

        # Test the initial MAX properties
        max_community_info = self.get_max_context_info(community)
        self.assertEqual('helou',
                         max_community_info.get(u'twitterHashtag', ''))
        self.assertFalse(max_community_info.get(u'notifications', False))
        self.assertTrue(u'[COMMUNITY]' in max_community_info.get('tags', []))

        for key in CLOSED_PERMISSIONS:
            self.assertEqual(max_community_info['permissions'].get(key, ''),
                             CLOSED_PERMISSIONS[key])
예제 #59
0
파일: base.py 프로젝트: tdiphale/bhp.lims-1
class SimpleTestLayer(PloneSandboxLayer):
    """Setup Plone with installed AddOn only
    """
    defaultBases = (
        BASE_LAYER_FIXTURE,
        PLONE_FIXTURE,
    )

    def setUpZope(self, app, configurationContext):
        super(SimpleTestLayer, self).setUpZope(app, configurationContext)

        # Load ZCML
        import archetypes.schemaextender
        import bika.lims
        import senaite.lims
        import bhp.lims

        self.loadZCML(package=archetypes.schemaextender)
        self.loadZCML(package=bika.lims)
        self.loadZCML(package=senaite.lims)
        self.loadZCML(package=bhp.lims)

        # Install product and call its initialize() function
        z2.installProduct(app, "bhp.lims")

    def setUpPloneSite(self, portal):
        super(SimpleTestLayer, self).setUpPloneSite(portal)

        # Apply Setup Profile (portal_quickinstaller)
        applyProfile(portal, "bika.lims:default")
        applyProfile(portal, "senaite.lims:default")
        applyProfile(portal, "bhp.lims:default")

        login(portal.aq_parent, SITE_OWNER_NAME)

        # Add some test users
        for role in ("LabManager", "LabClerk", "Analyst", "Verifier",
                     "Sampler", "Preserver", "Publisher", "Member", "Reviewer",
                     "RegulatoryInspector"):
            for user_nr in range(2):
                if user_nr == 0:
                    username = "******" % (role.lower())
                else:
                    username = "******" % (role.lower(), user_nr)
                try:
                    member = portal.portal_registration.addMember(
                        username,
                        username,
                        properties={
                            "username": username,
                            "email": username + "@example.com",
                            "fullname": username
                        })
                    # Add user to all specified groups
                    group_id = role + "s"
                    group = portal.portal_groups.getGroupById(group_id)
                    if group:
                        group.addMember(username)
                    # Add user to all specified roles
                    member._addRole(role)
                    # If user is in LabManagers, add Owner local role on
                    # clients folder
                    if role == "LabManager":
                        portal.clients.manage_setLocalRoles(
                            username, [
                                "Owner",
                            ])
                except ValueError:
                    pass  # user exists

        # Force the test browser to show the site always in 'en'
        ltool = portal.portal_languages
        ltool.manage_setLanguageSettings("en", ["en"],
                                         setUseCombinedLanguageCodes=False,
                                         startNeutral=True)

    logout()
예제 #60
0
    def test_community_subscribe_post(self):
        username = '******'
        login(self.portal, username)
        community = self.create_test_community()
        gwuuid = IGWUUID(community).get()

        acl = dict(users=[
            dict(id=u'janet.dura', displayName=u'Janet Durà', role=u'writer'),
            dict(id=u'victor.fernandez',
                 displayName=u'Víctor Fernández de Alba',
                 role=u'reader')
        ],
                   groups=[
                       dict(id=u'PAS', displayName=u'PAS UPC', role=u'writer'),
                       dict(id=u'UPCnet',
                            displayName=u'UPCnet',
                            role=u'reader')
                   ])

        subscriptions_view = self.request_API_endpoint(
            username, ['api', 'communities', gwuuid, 'subscriptions'],
            body=acl)
        httpretty.enable()
        http_mock_hub_syncacl(acl, self.settings.hub_server)
        response = subscriptions_view.POST()

        response = json.loads(response)
        self.assertEqual(subscriptions_view.request.response.getStatus(), 200)
        self.assertTrue('message' in response)
        self.assertEqual(ICommunityACL(community)().attrs['acl'], acl)
        self.assertEqual(
            ICommunityACL(community)().attrs['groups'], ['PAS', 'UPCnet'])
        logout()

        # Not allowed to change ACL
        username_not_allowed = 'ulearn.testuser2'
        login(self.portal, username_not_allowed)
        subscriptions_view = self.request_API_endpoint(
            username_not_allowed,
            ['api', 'communities', gwuuid, 'subscriptions'],
            body=acl)
        response = subscriptions_view.POST()
        response = json.loads(response)

        self.assertEqual(subscriptions_view.request.response.getStatus(), 404)
        logout()

        # Subscribed to community but not Owner
        login(self.portal, username)
        acl = dict(users=[
            dict(id=username_not_allowed, displayName=u'Test', role=u'writer'),
            dict(id=u'victor.fernandez',
                 displayName=u'Víctor Fernández de Alba',
                 role=u'reader')
        ],
                   groups=[
                       dict(id=u'PAS', displayName=u'PAS UPC', role=u'writer'),
                       dict(id=u'UPCnet',
                            displayName=u'UPCnet',
                            role=u'reader')
                   ])
        subscriptions_view = self.request_API_endpoint(
            username, ['api', 'communities', gwuuid, 'subscriptions'],
            body=acl)
        response = subscriptions_view.POST()
        response = json.loads(response)
        logout()

        login(self.portal, username_not_allowed)
        subscriptions_view = self.request_API_endpoint(
            username_not_allowed,
            ['api', 'communities', gwuuid, 'subscriptions'],
            body=acl)
        response = subscriptions_view.POST()
        response = json.loads(response)

        self.assertEqual(subscriptions_view.request.response.getStatus(), 404)
        logout()

        httpretty.disable()
        httpretty.reset()