class PrivateApplicationTestCase(TestCase):
"""
Tests for L{PrivateApplication}.
"""
def setUp(self):
self.siteStore = Store(filesdir=self.mktemp())
Mantissa().installSite(self.siteStore, u"example.com", u"", False)
self.userAccount = Create().addAccount(
self.siteStore, u'testuser', u'example.com', u'password')
self.userStore = self.userAccount.avatars.open()
self.privapp = PrivateApplication(store=self.userStore)
installOn(self.privapp, self.userStore)
self.webViewer = IWebViewer(self.userStore)
def test_createResourceUsername(self):
"""
L{PrivateApplication.createResourceWith} should figure out the
right username and pass it to L{_PrivateRootPage}.
"""
rootPage = self.privapp.createResourceWith(self.webViewer)
self.assertEqual(rootPage.username, u'*****@*****.**')
def test_getDocFactory(self):
"""
L{PrivateApplication.getDocFactory} finds a document factory for
the specified template name from among the installed themes.
"""
# Get something from the Mantissa theme
self.assertNotIdentical(self.privapp.getDocFactory('shell'), None)
# Get rid of the Mantissa offering and make sure the template is no
# longer found.
self.siteStore.query(InstalledOffering).deleteFromStore()
# And flush the cache. :/ -exarkun
theThemeCache.emptyCache()
self.assertIdentical(self.privapp.getDocFactory('shell'), None)
def test_powersUpWebViewer(self):
"""
L{PrivateApplication} should provide an indirected L{IWebViewer}
powerup, and its indirected powerup should be the default provider of
that interface.
"""
webViewer = IWebViewer(self.privapp.store)
self.assertIsInstance(webViewer, _AuthenticatedWebViewer)
self.assertIdentical(webViewer._privateApplication, self.privapp)
def test_producePrivateRoot(self):
"""
L{PrivateApplication.produceResource} should return a
L{_PrivateRootPage} when asked for '/private'.
"""
rsrc, segments = self.privapp.produceResource(FakeRequest(),
tuple(['private']), None)
self.assertIsInstance(rsrc, _PrivateRootPage)
self.assertEqual(segments, ())
def test_produceRedirect(self):
"""
L{_PrivateRootPage.produceResource} should return a redirect to
'/private/<default-private-id>' when asked for '/'.
This is a bad way to do it, because it isn't optional; all logged-in
users are instantly redirected to their private page, even if the
application has something interesting to display. See ticket #2708 for
details.
"""
item = FakeModelItem(store=self.userStore)
class TabThingy(object):
implements(INavigableElement)
def getTabs(self):
return [Tab("supertab", item.storeID, 1.0)]
tt = TabThingy()
self.userStore.inMemoryPowerUp(tt, INavigableElement)
rsrc, segments = self.privapp.produceResource(
FakeRequest(), tuple(['']), None)
self.assertIsInstance(rsrc, _PrivateRootPage)
self.assertEqual(segments, tuple(['']))
url, newSegs = rsrc.locateChild(FakeRequest(), ('',))
self.assertEqual(newSegs, ())
req = FakeRequest()
target = self.privapp.linkTo(item.storeID)
self.assertEqual('/'+url.path, target)
def test_produceNothing(self):
"""
L{_PrivateRootPage.produceResource} should return None when asked for a
resources other than '/' and '/private'.
"""
self.assertIdentical(
self.privapp.produceResource(FakeRequest(),
tuple(['hello', 'world']),
None),
None)
def test_privateRootHasWebViewer(self):
"""
The L{_PrivateRootPage} returned from
L{PrivateApplication.produceResource} should refer to an
L{IWebViewer}.
"""
webViewer = object()
rsrc, segments = self.privapp.produceResource(
FakeRequest(),
tuple(['private']), webViewer)
self.assertIdentical(webViewer,
rsrc.webViewer)
class WebIDLocationTest(TestCase):
def setUp(self):
store = Store()
ss = SubStore.createNew(store, ['test']).open()
self.pa = PrivateApplication(store=ss)
installOn(self.pa, ss)
self.webViewer = IWebViewer(ss)
def test_powersUpTemplateNameResolver(self):
"""
L{PrivateApplication} implements L{ITemplateNameResolver} and should
power up the store it is installed on for that interface.
"""
self.assertIn(
self.pa,
self.pa.store.powerupsFor(ITemplateNameResolver))
def test_suchWebID(self):
"""
Verify that retrieving a webID gives the correct resource.
"""
i = FakeResourceItem(store=self.pa.store)
wid = self.pa.toWebID(i)
ctx = FakeRequest()
res = self.pa.createResourceWith(self.webViewer)
self.assertEqual(res.locateChild(ctx, [wid]),
(i, []))
def test_noSuchWebID(self):
"""
Verify that non-existent private URLs generate 'not found' responses.
"""
ctx = FakeRequest()
for segments in [
# something that looks like a valid webID
['0000000000000000'],
# something that doesn't
["nothing-here"],
# more than one segment
["two", "segments"]]:
res = self.pa.createResourceWith(self.webViewer)
self.assertEqual(res.locateChild(ctx, segments),
rend.NotFound)
def test_webIDForFragment(self):
"""
Retrieving a webID that specifies a fragment gives the correct
resource.
"""
class FakeView(record("model")):
"A fake view that wraps a FakeModelItem."
class FakeWebViewer(object):
def wrapModel(self, model):
return FakeView(model)
i = FakeModelItem(store=self.pa.store)
wid = self.pa.toWebID(i)
ctx = FakeRequest()
res = self.pa.createResourceWith(FakeWebViewer())
child, segs = res.locateChild(ctx, [wid])
self.assertIsInstance(child, FakeView)
self.assertIdentical(child.model, i)
