def test_differentUserSameID(self): """ Verify that if different facets of the same item are shared to different users with the same shareID, each user will receive the correct respective facet with only the correct methods exposed. """ t = PrivateThing(store=self.store, publicData=789) toBob = sharing.shareItem(t, toName=u'*****@*****.**', interfaces=[IReadOnly]) toAlice = sharing.shareItem(t, toName=u'*****@*****.**', shareID=toBob.shareID, interfaces=[IPrivateThing]) # Sanity check. self.assertEquals(toBob.shareID, toAlice.shareID) asBob = sharing.getShare(self.store, sharing.getPrimaryRole( self.store, u'*****@*****.**'), toBob.shareID) asAlice = sharing.getShare(self.store, sharing.getPrimaryRole( self.store, u'*****@*****.**'), toBob.shareID) self.assertEquals(asBob.retrieveSomeState(), 789) self.assertRaises(AttributeError, lambda : asBob.mutateSomeState) self.assertRaises(AttributeError, lambda : asAlice.retrieveSomeState) asAlice.mutateSomeState() # Make sure they're both seeing the same item. self.assertEquals(asBob.retrieveSomeState(), 789+5)
def test_shareToAuthorOnly(self): """ Test that creating a blurb with a single entry for the author in the C{roleToPerms} dictionary results in a share that can't be accessed by anybody else """ shareID = self.blog.post(u'', u'', self.me, {self.me: [ihyperbola.IViewable]}) self.failUnless(getShare(self.userStore, self.me, shareID)) self.assertRaises(NoSuchShare, lambda: getShare(self.userStore, self.you, shareID))
def test_shareToAuthorOnly(self): """ Test that creating a blurb with a single entry for the author in the C{roleToPerms} dictionary results in a share that can't be accessed by anybody else """ shareID = self.blog.post( u'', u'', self.me, {self.me: [ihyperbola.IViewable]}) self.failUnless(getShare(self.userStore, self.me, shareID)) self.assertRaises( NoSuchShare, lambda: getShare(self.userStore, self.you, shareID))
def test_editPermsAuthorOnly(self): """ Test that creating a blurb with the default permissions and then editing the perms to only allow the author to view the post results in a share that can't be accessed by anybody else """ shareID = self.blog.post(u'', u'', self.me) share = getShare(self.userStore, self.me, shareID) shareID = itemFromProxy(share).editPermissions( {self.me: [ihyperbola.IViewable]}) share = getShare(self.userStore, self.me, shareID) self.assertRaises(NoSuchShare, lambda: getShare(self.userStore, self.you, shareID))
def test_editPermsAuthorOnly(self): """ Test that creating a blurb with the default permissions and then editing the perms to only allow the author to view the post results in a share that can't be accessed by anybody else """ shareID = self.blog.post(u'', u'', self.me) share = getShare(self.userStore, self.me, shareID) shareID = itemFromProxy(share).editPermissions( {self.me: [ihyperbola.IViewable]}) share = getShare(self.userStore, self.me, shareID) self.assertRaises( NoSuchShare, lambda: getShare(self.userStore, self.you, shareID))
def test_listingNestedChildren(self): """ Verify that if a post is made on a blog and comments are made on it, they will be returned by listing the children of that blog. """ shareID1 = self.blog.post(u'My First Post', u'Hello, Viewers', self.me) post = getShare(self.userStore, self.you, shareID1) shareID2 = post.post(u'a comment', u'O RLY?', self.you) post2 = getShare(self.userStore, self.me, shareID2) shareID3 = post2.post(u'another comment', u'YA RLY!', self.me) posts = list(post.view(self.you)) self.assertEquals(len(posts), 1) self.assertEquals(posts[0].shareID, shareID2)
def test_listingNestedChildren(self): """ Verify that if a post is made on a blog and comments are made on it, they will be returned by listing the children of that blog. """ shareID1 = self.blog.post( u'My First Post', u'Hello, Viewers', self.me) post = getShare(self.userStore, self.you, shareID1) shareID2 = post.post(u'a comment', u'O RLY?', self.you) post2 = getShare(self.userStore, self.me, shareID2) shareID3 = post2.post(u'another comment', u'YA RLY!', self.me) posts = list(post.view(self.you)) self.assertEquals(len(posts), 1) self.assertEquals(posts[0].shareID, shareID2)
def test_tagsNoTags(self): """ Test that L{hyperbola.hyperblurb.Blurb.tags} returns an empty iterable when there are no tags """ shareID = self.blog.post(u'', u'', self.me) post = getShare(self.userStore, self.me, shareID) self.assertEquals(list(post.tags()), [])
def test_linkToProxy(self): """ Test that L{xmantissa.websharing.linkTo} generates a URL that I can link to. """ self._verifyPath( websharing.linkTo(sharing.getShare(self.s, sharing.getEveryoneRole( self.s), u'loginsystem')))
def test_tagging(self): """ Test that blurb tagging works """ shareID = self.blog.post(u'', u'', self.me) post = getShare(self.userStore, self.me, shareID) post.tag(u'foo') post.tag(u'bar') self.assertEquals(list(post.tags()), ['foo', 'bar'])
def test_linkToProxy(self): """ Test that L{xmantissa.websharing.linkTo} generates a URL that I can link to. """ self._verifyPath( websharing.linkTo( sharing.getShare(self.s, sharing.getEveryoneRole(self.s), u'loginsystem')))
def test_viewByTag(self): """ Test that L{hyperbola.hyperblurb.Blurb.viewByTag} only returns children with the given tag """ post1 = getShare(self.userStore, self.me, self.blog.post(u'', u'', self.me)) post2 = getShare(self.userStore, self.me, self.blog.post(u'', u'', self.me)) post3 = getShare(self.userStore, self.me, self.blog.post(u'', u'', self.me)) post1.tag(u'foo') post1.tag(u'bar') post2.tag(u'bar') self.assertEquals( [p.shareID for p in self.blog.viewByTag(self.me, u'bar')], [post2.shareID, post1.shareID])
def test_viewByTag(self): """ Test that L{hyperbola.hyperblurb.Blurb.viewByTag} only returns children with the given tag """ post1 = getShare( self.userStore, self.me, self.blog.post(u'', u'', self.me)) post2 = getShare( self.userStore, self.me, self.blog.post(u'', u'', self.me)) post3 = getShare( self.userStore, self.me, self.blog.post(u'', u'', self.me)) post1.tag(u'foo') post1.tag(u'bar') post2.tag(u'bar') self.assertEquals( [p.shareID for p in self.blog.viewByTag(self.me, u'bar')], [post2.shareID, post1.shareID])
def test_editTags(self): """ Test that L{hyperbola.hyperblurb.Blurb.edit} changes the tags of the blurb """ postShareID = self.blog.post(u'', u'', self.me) sharedPost = getShare(self.userStore, self.me, postShareID) sharedPost.tag(u'foo') sharedPost.tag(u'bar') self.assertEquals(set(sharedPost.tags()), set(('foo', 'bar'))) sharedPost.edit(u'', u'', self.me, (u'foo', u'baz')) self.assertEquals(set(sharedPost.tags()), set(('foo', 'baz')))
def test_defaultShareIDInteractionNoMatch(self): """ Verify that L{websharing.linkTo} explicitly includes a share ID in the URL if the ID of the share it is passed doesn't match the default. """ websharing.addDefaultShareID(self.s, u'share-id', 0) shareable = Shareable(store=self.s) sharing.shareItem(Shareable(store=self.s), shareID=u'not-the-share-id') share = sharing.getShare(self.s, sharing.getEveryoneRole(self.s), u'not-the-share-id') url = websharing.linkTo(share) self.assertEqual(str(url), '/users/right/not-the-share-id')
def test_postPermissions(self): """ Verify that a post made on the blog by its owner cannot be commented on by people who are not authorized to comment on it. """ postShareID = self.blog.post(u'My First Post', u'Hello, Viewers', self.me) self.assertNotIdentical(postShareID, None) sharedPost = getShare(self.userStore, self.you, postShareID) commentShareID = sharedPost.post(u'My Comemnt To Your Post', u'Your Bolg Sucks, man', self.you) self.assertNotIdentical(commentShareID, None) sharedComment = getShare(self.userStore, self.you, commentShareID) self.assertIdentical(sharedComment.parent, itemFromProxy(sharedPost)) self.assertRaises(AttributeError, lambda: sharedPost.edit( u'Ima Haxer', u'Haxed u', self.you, ())) newTitle = u'My Comment To Your Post' newBody = u'Your Blog Sucks, man' sharedComment.edit(newTitle, newBody, self.you, ()) self.assertEquals(sharedComment.body, newBody) self.assertEquals(sharedComment.title, newTitle)
def test_defaultShareIDInteractionNoMatch(self): """ Verify that L{websharing.linkTo} explicitly includes a share ID in the URL if the ID of the share it is passed doesn't match the default. """ websharing.addDefaultShareID(self.s, u'share-id', 0) shareable = Shareable(store=self.s) sharing.shareItem(Shareable(store=self.s), shareID=u'not-the-share-id') share = sharing.getShare( self.s, sharing.getEveryoneRole(self.s), u'not-the-share-id') url = websharing.linkTo(share) self.assertEqual(str(url), '/users/right/not-the-share-id')
def test_postPermissions(self): """ Verify that a post made on the blog by its owner cannot be commented on by people who are not authorized to comment on it. """ postShareID = self.blog.post(u'My First Post', u'Hello, Viewers', self.me) self.assertNotIdentical(postShareID, None) sharedPost = getShare(self.userStore, self.you, postShareID) commentShareID = sharedPost.post(u'My Comemnt To Your Post', u'Your Bolg Sucks, man', self.you) self.assertNotIdentical(commentShareID, None) sharedComment = getShare(self.userStore, self.you, commentShareID) self.assertIdentical(sharedComment.parent, itemFromProxy(sharedPost)) self.assertRaises( AttributeError, lambda: sharedPost.edit(u'Ima Haxer', u'Haxed u', self.you, ())) newTitle = u'My Comment To Your Post' newBody = u'Your Blog Sucks, man' sharedComment.edit(newTitle, newBody, self.you, ()) self.assertEquals(sharedComment.body, newBody) self.assertEquals(sharedComment.title, newTitle)
def _shareAndGetProxy(self, blurb): """ Share C{blurb} to everyone and return a shared proxy @param blurb: a blurb @type blurb: L{hyperbola.hyperblurb.Blurb} @rtype: L{xmantissa.sharing.SharedProxy} """ share = sharing.shareItem(blurb) return sharing.getShare(self.userStore, sharing.getEveryoneRole(self.userStore), share.shareID)
def test_defaultShareIDInteractionMatching(self): """ Verify that L{websharing.linkTo} does not explicitly include a share ID in the URL if the ID of the share it is passed matches the default. """ websharing.addDefaultShareID(self.s, u'share-id', 0) sharing.shareItem(Shareable(store=self.s), shareID=u'share-id') share = sharing.getShare( self.s, sharing.getEveryoneRole(self.s), u'share-id') url = websharing.linkTo(share) self.assertEqual(str(url), '/users/right/') # and if we call child() self.assertEqual(str(url.child('child')), '/users/right/share-id/child')
def test_getShareProxyWithAdapter(self): """ When you share an item with an interface that has an adapter for that interface, the object that results from getShare should provide the interface by exposing the adapter rather than the original item. """ privateThing = PrivateThing(store=self.store) shared = sharing.shareItem(privateThing, toName=u'testshare', interfaces=[IExternal]) proxy = sharing.getShare(self.store, sharing.getPrimaryRole(self.store, u'testshare'), shared.shareID) proxy.doExternal() self.assertTrue(privateThing.externalized)
def setUp(self): """ Set up an environment suitable for testing the share-handling functionality of L{hyperbola_view.ShareScrollingElement}. """ self._setUpStore() blogShare = self._shareAndGetProxy(self._makeBlurb(FLAVOR.BLOG)) EVERYBODY = sharing.getEveryoneRole(self.userStore) sharing.itemFromProxy(blogShare).permitChildren( EVERYBODY, FLAVOR.BLOG_POST, ihyperbola.IViewable) # For sanity's sake, let's not have the role of the view and the role # implicitly chosen by not calling 'customizeFor' disagree. (This # shouldn't be possible anyway, and in the future getRole should just # be looking at its proxy.) self.publicBlogShare = sharing.getShare( self.userStore, EVERYBODY, blogShare.shareID) selfRole = sharing.getSelfRole(self.userStore) blogPostShareID = blogShare.post(u'', u'', selfRole) self.blogPostSharedToEveryone = sharing.getShare( self.userStore, EVERYBODY, blogPostShareID) self.blogPostItem = sharing.itemFromProxy(self.blogPostSharedToEveryone)
def _shareAndGetProxy(self, blurb): """ Share C{blurb} to everyone and return a shared proxy @param blurb: a blurb @type blurb: L{hyperbola.hyperblurb.Blurb} @rtype: L{xmantissa.sharing.SharedProxy} """ share = sharing.shareItem(blurb) return sharing.getShare( self.userStore, sharing.getEveryoneRole(self.userStore), share.shareID)
def test_defaultShareIDInteractionMatching(self): """ Verify that L{websharing.linkTo} does not explicitly include a share ID in the URL if the ID of the share it is passed matches the default. """ websharing.addDefaultShareID(self.s, u'share-id', 0) sharing.shareItem(Shareable(store=self.s), shareID=u'share-id') share = sharing.getShare(self.s, sharing.getEveryoneRole(self.s), u'share-id') url = websharing.linkTo(share) self.assertEqual(str(url), '/users/right/') # and if we call child() self.assertEqual(str(url.child('child')), '/users/right/share-id/child')
def test_editLinkIfEditable(self): """ Test that L{hyperbola_view.BlogPostBlurbViewer} renders an 'edit' link if the underlying blurb is editable. """ post = self._makeBlurb(hyperblurb.FLAVOR.BLOG_POST) authorShareID = sharing.shareItem( post, toRole=sharing.getSelfRole(self.userStore), interfaces=[ihyperbola.IEditable]).shareID authorPostShare = sharing.getShare( self.userStore, sharing.getSelfRole(self.userStore), authorShareID) authorPostView = hyperbola_view.blurbViewDispatcher(authorPostShare) tag = tags.invisible(foo='bar') result = authorPostView.editLink(None, tag) self.assertIdentical(result, tag)
def test_shareAndAdapt(self): """ Verify that when an item is shared to a particular user with a particular interface, retrieving it for that user results in methods on the given interface being callable and other methods being restricted. """ t = PrivateThing(store=self.store, publicData=789) # Sanity check. self.failUnless(IPublicThing(t).isMethodAvailable()) shared = sharing.shareItem(t, toName=u'testshare', interfaces=[IReadOnly]) proxy = sharing.getShare(self.store, sharing.getPrimaryRole(self.store, u'testshare'), shared.shareID) self.assertFalse(IPublicThing(proxy).isMethodAvailable()) self.assertRaises(AttributeError, IPublicThing(proxy).callMethod)
def test_twoInterfacesTwoGroups(self): """ Verify that when an item is shared to two roles that a user is a member of, they will have access to both interfaces when it is retrieved with getShare. """ self.addSomeThings() us = sharing.getPrimaryRole(self.store, u'us', True) them = sharing.getPrimaryRole(self.store, u'them', True) self.bob.becomeMemberOf(us) self.bob.becomeMemberOf(them) it = PrivateThing(store=self.store, publicData=1234) sharing.shareItem(it, toRole=us, shareID=u'q', interfaces=[IPrivateThing]) sharing.shareItem(it, toRole=them, shareID=u'q', interfaces=[IReadOnly]) that = sharing.getShare(self.store, self.bob, u'q') self.assertEquals(that.retrieveSomeState(), 1234) that.mutateSomeState() self.assertEquals(that.retrieveSomeState(), 1239)
def test_coalesceInheritedAdapters(self): """ If multiple interfaces that are part of the same inheritance hierarchy are specified, only the leaf interfaces should be adapted to, and provided for all interfaces it inherits from. """ extraPrivateThing = ExtraPrivateThing(store=self.store) role = sharing.getPrimaryRole(self.store, u'testshare') extraProxy = sharing.getShare( self.store, role, sharing.shareItem( extraPrivateThing, toRole=role, interfaces=[IExternal, IExtraExternal]).shareID) externalTag, externalObj = extraProxy.doExternal() extraExternalTag, extraExternalObj = extraProxy.doExternalExtra() self.assertIdentical(externalObj, extraExternalObj) self.assertEquals(externalTag, 'external') self.assertEquals(extraExternalTag, 'external-extra')
def addComment(self, title, body, tags): """ Add a comment blurb to our parent blurb @param title: the title of the comment @type title: C{unicode} @param body: the body of the comment @type body: C{unicode} @param tags: tags to apply to the comment @type tags: iterable of C{unicode} @rtype: C{None} """ shareID = self.parent.original.post(title, body, self.parent.getRole()) role = self.parent.getRole() # is role.store correct? post = sharing.getShare(role.store, role, shareID) for tag in tags: post.tag(tag)
def test_simpleShare(self): """ Verify that an item which is shared with shareItem can be retrieved and manipulated with getShare. This is an older-style API, on its way to deprecation. """ t = PrivateThing(store=self.store, publicData=456) shareItemResult = self.assertWarns( PendingDeprecationWarning, "Use Role.shareItem() instead of sharing.shareItem().", __file__, lambda : sharing.shareItem(t, toName=u'*****@*****.**')) bob = sharing.getPrimaryRole(self.store, u'*****@*****.**') gotShare = self.assertWarns( PendingDeprecationWarning, "Use Role.getShare() instead of sharing.getShare().", __file__, lambda : sharing.getShare(self.store, bob, shareItemResult.shareID)) gotShare.mutateSomeState() self.assertEquals(t.publicData, 456 + 5)