def test_normalization(self, value): """ Inserting a value and then searching with a search equal to that value over normalization returns the inserted entry. """ assume(value != u'') s = Store() def _tx(): SearchEntry.insert(s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type', value) for mutation in [casefold, spaced, punctuated]: self.assertThat( list( SearchEntry.search(s, SearchClasses.EXACT, u'e', u'i', mutation(value))), Annotate( 'Not found for {!r}({!r}) == {!r}'.format( mutation, value, mutation(value)), Equals([{ u'result': u'RESULT', u'type': u'type' }]))) s.transact(_tx)
def saveStub(funcobj, revision): """ Create a stub database and populate it using the given function. @param funcobj: A one-argument callable which will be invoked with an Axiom Store instance and should add to it the old state which will be used to test an upgrade. @param revision: An SVN revision of trunk at which it was possible it is possible for funcobj to create the necessary state. """ # You may notice certain files don't pass the second argument. They don't # work any more. Please feel free to update them with the revision number # they were created at. filename = inspect.getfile(funcobj) dbfn = os.path.join( os.path.dirname(filename), os.path.basename(filename).split("stub_")[1].split('.py')[0]+'.axiom') s = Store(dbfn) s.transact(funcobj, s) s.close() tarball = tarfile.open(dbfn+'.tbz2', 'w:bz2') tarball.add(os.path.basename(dbfn)) tarball.close() shutil.rmtree(dbfn)
class IntegrationTestsMixin: """ L{TestCase} mixin defining setup and teardown such that requests can be made against a site strongly resembling an actual one. @type store: L{Store} @ivar store: The site store. @type web: L{WebSite} @ivar web: The site store's web site. @type login: L{LoginSystem} @ivar login: The site store's login system. @ivar site: A protocol factory created by the site store's L{WebSite}. This is probably a L{NevowSite}, but that should be an irrelevant detail. @type domain: C{unicode} @ivar domain: The canonical name of the website and the domain part used when creating users. """ domain = u'example.com' def setUp(self): """ Create a L{Store} with a L{WebSite} in it. Get a protocol factory from the website and save it for tests to use. Patch L{twisted.web.http} and L{nevow.guard} so that they don't create garbage timed calls that have to be cleaned up. """ self.store = Store(filesdir=self.mktemp()) # See #2484 def _tx(): Mantissa().installSite(self.store, self.domain, u'', False) self.site = self.store.findUnique(SiteConfiguration) self.login = self.store.findUnique(LoginSystem) # Ports should be offering installation parameters. This assumes a # TCPPort and an SSLPort are created by Mantissa.installSite. See # #538. -exarkun self.store.query(SSLPort, SSLPort.factory == self.site).deleteFromStore() self.factory = self.site.getFactory() self.store.transact(_tx) self.origFunctions = (GuardSession.checkExpired.im_func, athena.ReliableMessageDelivery) GuardSession.checkExpired = lambda self: None athena.ReliableMessageDelivery = lambda *a, **kw: None def tearDown(self): """ Restore the patched functions to their original state. """ GuardSession.checkExpired = self.origFunctions[0] athena.ReliableMessageDelivery = self.origFunctions[1] del self.origFunctions
def initialize(db: store.Store, options: usage.Options): initializers = [] initializePermissions(db) adm = IEmployee(1, None) if not adm: adm = IEmployee(NULL) adm.employee_id = 1 adm.alternate_authentication = StaticAuthenticationMethod(store=adm.store).setPassword("xyzzy") adm1 = IAdministrator(NULL) adm1.employee = adm adm.powerUp(adm1, IAdministrator) if db.filesdir: l = Logger(store=db.store) l.file = File(store=db.store, path=db.store.filesdir.child('Commands.log').path) l.flags = 1 | 2 | 4 | 8 l.name = "Command Logger" IEventBus("Commands").powerUp(l, ICommandEvent) initializers = [initializeCommands, initializeAPIs] if Solomon.pymssql: initializers.append(initializeSubAccounts) initializers.append(initializeWorkLocations) initializers.append(lambda d: initializeDB(d, options)) else: wl = IWorkLocation(NULL) wl.description = 'test' wl.workLocationID = "TST" sa = ISubAccount(NULL) sa.name = 'test' sa.sub = 1 db.transact(lambda: [i(db) for i in initializers])
def testBasicQuery(self): s = Store() def entesten(): c1 = C(store=s, name=u'yes') c2 = C(store=s, name=u'no') A(store=s, reftoc=c1, type=u'testc') A(store=s, reftoc=c2, type=u'testc') A(store=s, reftoc=c1, type=u'testx') yesb = B(store=s, cref=c1, name=u'correct') B(store=s, cref=c2, name=u'not correct') s.checkpoint() q = list( s.query( B, AND(AND(C.name == u'yes', A.type == u'testc'), AND(C.storeID == B.cref, A.reftoc == C.storeID)), )) self.assertEquals(q, [yesb]) s.transact(entesten) s.close()
def saveStub(funcobj, revision): """ Create a stub database and populate it using the given function. @param funcobj: A one-argument callable which will be invoked with an Axiom Store instance and should add to it the old state which will be used to test an upgrade. @param revision: An SVN revision of trunk at which it was possible it is possible for funcobj to create the necessary state. """ # You may notice certain files don't pass the second argument. They don't # work any more. Please feel free to update them with the revision number # they were created at. filename = inspect.getfile(funcobj) dbfn = os.path.join( os.path.dirname(filename), os.path.basename(filename).split("stub_")[1].split('.py')[0]+'.axiom') s = Store(dbfn) s.transact(funcobj, s) s.close() tarball = tarfile.open(dbfn+'.tbz2', 'w:bz2') tarball.add(os.path.basename(dbfn)) tarball.close() shutil.rmtree(dbfn)
def main(): s = Store("TEMPORARY.axiom") rows = [(x, unicode(x)) for x in xrange(10000)] s.transact(lambda: s.batchInsert(AB, (AB.a, AB.b), rows)) benchmark.start() s.transact(s.query(AB).deleteFromStore) benchmark.stop()
def main(): s = Store("TEMPORARY.axiom") rows = [(x, unicode(x)) for x in xrange(10000)] s.transact(lambda: s.batchInsert(AB, (AB.a, AB.b), rows)) benchmark.start() s.transact(s.query(AB).deleteFromStore) benchmark.stop()
def main(): s = Store("TEMPORARY.axiom") def txn(): for x in range(10000): AB(a=x, b=unicode(x), store=s) benchmark.start() s.transact(txn) benchmark.stop()
def main(): s = Store("TEMPORARY.axiom") def txn(): for x in range(10000): AB(a=x, b=str(x), store=s) benchmark.start() s.transact(txn) benchmark.stop()
def main(): s = Store("TEMPORARY.axiom") rows = [(x, str(x)) for x in range(10000)] s.transact(lambda: s.batchInsert(AB, (AB.a, AB.b), rows)) def deleteStuff(): for it in s.query(AB): it.deleteFromStore() benchmark.start() s.transact(deleteStuff) benchmark.stop()
def test_prefixSearches(self, environment, indexType, searchValue, searchType, result): """ Test inserting, searching, and removing for the prefix search class. """ assume(SearchEntry._normalize(searchValue[:3]) != u'') s = Store() def _tx(): SearchEntry.insert(s, SearchClasses.PREFIX, environment, indexType, result, searchType, searchValue) self.assertThat( list( SearchEntry.search(s, SearchClasses.PREFIX, environment, indexType, searchValue[:3])), Equals([{ u'result': result, u'type': searchType }])) self.assertThat( list( SearchEntry.search(s, SearchClasses.PREFIX, environment, indexType, 'a' + searchValue)), Equals([])) self.assertThat( list( SearchEntry.search(s, SearchClasses.PREFIX, environment, indexType, searchValue)), Equals([{ u'result': result, u'type': searchType }])) self.assertThat( list( SearchEntry.search(s, SearchClasses.PREFIX, environment, indexType, searchValue, searchType)), Equals([{ u'result': result, u'type': searchType }])) SearchEntry.remove(s, SearchClasses.PREFIX, environment, indexType, result, searchType) self.assertThat( list( SearchEntry.search(s, SearchClasses.PREFIX, environment, indexType, searchValue)), Equals([])) self.assertThat( list( SearchEntry.search(s, SearchClasses.PREFIX, environment, indexType, searchValue, searchType)), Equals([])) s.transact(_tx)
def testAttributeQueryCount(self): s = Store() def entesten(): E(store=s, name=u'a', amount=123) E(store=s, name=u'b', amount=456) E(store=s, name=u'c') # no amount given self.assertEquals(s.query(E).getColumn("amount").count(), 2) s.transact(entesten) s.close()
def test_separateTransactions(self): """ Verify that 'paginate' is iterable in separate transactions. """ s = Store() b1 = SingleColumnSortHelper(store=s, mainColumn=1) b2 = SingleColumnSortHelper(store=s, mainColumn=2) b3 = SingleColumnSortHelper(store=s, mainColumn=3) itr = s.transact(lambda : iter(s.query(SingleColumnSortHelper).paginate())) self.assertIdentical(s.transact(itr.next), b1) self.assertEquals(s.transact(lambda : (itr.next(), itr.next())), (b2, b3)) self.assertRaises(StopIteration, lambda : s.transact(itr.next))
def testAttributeQueries(self): s = Store() def entesten(): E(store=s, name=u'b', amount=456) E(store=s, name=u'a', amount=123) E(store=s, name=u'c', amount=789) self.assertEquals( list(s.query(E, sort=E.name.ascending).getColumn("amount")), [123, 456, 789]) s.transact(entesten) s.close()
def test_separateTransactions(self): """ Verify that 'paginate' is iterable in separate transactions. """ s = Store() b1 = SingleColumnSortHelper(store=s, mainColumn=1) b2 = SingleColumnSortHelper(store=s, mainColumn=2) b3 = SingleColumnSortHelper(store=s, mainColumn=3) itr = s.transact(lambda : iter(s.query(SingleColumnSortHelper).paginate())) self.assertIdentical(s.transact(itr.__next__), b1) self.assertEqual(s.transact(lambda : (next(itr), next(itr))), (b2, b3)) self.assertRaises(StopIteration, lambda : s.transact(itr.__next__))
class TestCountQuery(TestCase): RANGE = 10 MIDDLE = 5 def assertCountEqualsQuery(self, item, cond=None): self.assertEqual( self.store.count(item, cond), len(list(self.store.query(item, cond))), 'count and len(list(query)) not equals: %r,%r' % (item, cond)) def setUp(self): self.store = Store() def populate(): for i in range(self.RANGE): for j in range(self.RANGE): ThingsWithIntegers(store=self.store, a=i, b=j) self.store.transact(populate) def testBasicCount(self): self.assertCountEqualsQuery(ThingsWithIntegers) def testSimpleConditionCount(self): self.assertCountEqualsQuery(ThingsWithIntegers, ThingsWithIntegers.a > self.MIDDLE) def testTwoFieldsConditionCount(self): self.assertCountEqualsQuery( ThingsWithIntegers, ThingsWithIntegers.a == ThingsWithIntegers.b) def testANDConditionCount(self): self.assertCountEqualsQuery( ThingsWithIntegers, AND(ThingsWithIntegers.a > self.MIDDLE, ThingsWithIntegers.b < self.MIDDLE)) def testORConditionCount(self): self.assertCountEqualsQuery( ThingsWithIntegers, OR(ThingsWithIntegers.a > self.MIDDLE, ThingsWithIntegers.b < self.MIDDLE)) def testEmptyResult(self): self.assertCountEqualsQuery(ThingsWithIntegers, ThingsWithIntegers.a == self.RANGE + 3) def testNonExistentTable(self): self.assertCountEqualsQuery( NotARealThing, NotARealThing.irrelevantAttribute == self.RANGE + 3)
def test_inserts(self, values): """ Test inserting and retrieving arbitrary entries. """ s = Store() def _tx(): d = {} for e, t, k, v in values: LookupEntry.set(s, e, t, k, v) d[(_lower(e), _lower(t), _lower(k))] = v self.assertThat(LookupEntry.get(s, e, t, k), Equals(v)) for (e, t, k), v in d.iteritems(): self.assertThat(LookupEntry.get(s, e, t, k), Equals(v)) s.transact(_tx)
def test_dummyItemReferenceInUpgrade(self): """ Setting the value of a reference attribute to a legacy item during an upgrade results in the same value being set on the upgraded item. """ store = Store() def tx(): oldReferent = nonUpgradedItem(store=store) oldReferee = nonUpgradedItem(store=store) newReferent = oldReferent.upgradeVersion( UpgradedItem.typeName, 1, 2) newReferee = oldReferee.upgradeVersion( UpgradedItem.typeName, 1, 2, ref=newReferent) self.assertIdentical(newReferee.ref, newReferent) store.transact(tx)
def test_dummyItemReferenceInUpgrade(self): """ Setting the value of a reference attribute to a legacy item during an upgrade results in the same value being set on the upgraded item. """ store = Store() def tx(): oldReferent = nonUpgradedItem(store=store) oldReferee = nonUpgradedItem(store=store) newReferent = oldReferent.upgradeVersion( UpgradedItem.typeName, 1, 2) newReferee = oldReferee.upgradeVersion( UpgradedItem.typeName, 1, 2, ref=newReferent) self.assertIdentical(newReferee.ref, newReferent) store.transact(tx)
def testAttributeQueryDistinct(self): s = Store() def entesten(): E(store=s, name=u'a', amount=123) E(store=s, name=u'b', amount=789) E(store=s, name=u'a', amount=456) self.assertEquals( list( s.query( E, sort=E.name.ascending).getColumn("name").distinct()), [u"a", u"b"]) s.transact(entesten) s.close()
def test_prefixSearches(self, environment, indexType, searchValue, searchType, result): """ Test inserting, searching, and removing for the prefix search class. """ assume(SearchEntry._normalize(searchValue) != u'') s = Store() def _tx(): SearchEntry.insert( s, SearchClasses.PREFIX, environment, indexType, result, searchType, searchValue) self.assertThat( list(SearchEntry.search( s, SearchClasses.PREFIX, environment, indexType, searchValue[:3])), Equals([result])) self.assertThat( list(SearchEntry.search( s, SearchClasses.PREFIX, environment, indexType, 'a' + searchValue)), Equals([])) self.assertThat( list(SearchEntry.search( s, SearchClasses.PREFIX, environment, indexType, searchValue)), Equals([result])) self.assertThat( list(SearchEntry.search( s, SearchClasses.PREFIX, environment, indexType, searchValue, searchType)), Equals([result])) SearchEntry.remove( s, SearchClasses.PREFIX, environment, indexType, result, searchType) self.assertThat( list(SearchEntry.search( s, SearchClasses.PREFIX, environment, indexType, searchValue)), Equals([])) self.assertThat( list(SearchEntry.search( s, SearchClasses.PREFIX, environment, indexType, searchValue, searchType)), Equals([])) s.transact(_tx)
def test_insertEmpty(self): """ Inserting a value that is empty after normalization instead deletes the entry. """ s = Store() def _tx(): SearchEntry.insert( s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type', u'. /') self.assertThat(s.query(SearchEntry).count(), Equals(0)) SearchEntry.insert( s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type', u'yo') self.assertThat(s.query(SearchEntry).count(), Equals(1)) SearchEntry.insert( s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type', u'. /') self.assertThat(s.query(SearchEntry).count(), Equals(0)) s.transact(_tx)
class TestCountQuery(TestCase): RANGE = 10 MIDDLE = 5 def assertCountEqualsQuery(self, item, cond = None): self.assertEquals(self.store.count(item, cond), len(list(self.store.query(item, cond))), 'count and len(list(query)) not equals: %r,%r'%(item, cond)) def setUp(self): self.store = Store() def populate(): for i in xrange(self.RANGE): for j in xrange(self.RANGE): ThingsWithIntegers(store = self.store, a = i, b = j) self.store.transact(populate) def testBasicCount(self): self.assertCountEqualsQuery(ThingsWithIntegers) def testSimpleConditionCount(self): self.assertCountEqualsQuery(ThingsWithIntegers, ThingsWithIntegers.a > self.MIDDLE) def testTwoFieldsConditionCount(self): self.assertCountEqualsQuery(ThingsWithIntegers, ThingsWithIntegers.a == ThingsWithIntegers.b) def testANDConditionCount(self): self.assertCountEqualsQuery(ThingsWithIntegers, AND(ThingsWithIntegers.a > self.MIDDLE, ThingsWithIntegers.b < self.MIDDLE)) def testORConditionCount(self): self.assertCountEqualsQuery(ThingsWithIntegers, OR(ThingsWithIntegers.a > self.MIDDLE, ThingsWithIntegers.b < self.MIDDLE)) def testEmptyResult(self): self.assertCountEqualsQuery(ThingsWithIntegers, ThingsWithIntegers.a == self.RANGE + 3) def testNonExistentTable(self): self.assertCountEqualsQuery(NotARealThing, NotARealThing.irrelevantAttribute == self.RANGE + 3)
def testAggregateQueries(self): s = Store() def entesten(): self.assertEquals(s.query(E).count(), 0) self.assertEquals(s.query(E).getColumn("amount").sum(), 0) e1 = E(store=s, name=u'widgets', amount=37) e2 = E(store=s, name=u'widgets', amount=63) e3 = E(store=s, name=u'quatloos', amount=99, transaction=u'yes') s.checkpoint() q = s.count(E, E.name == u'widgets') self.failUnlessEqual(q, 2) q = s.sum(E.amount, E.name == u'widgets') self.failUnlessEqual(q, 100) s.transact(entesten) s.close()
def test_insertEmpty(self): """ Inserting a value that is empty after normalization instead deletes the entry. """ s = Store() def _tx(): SearchEntry.insert(s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type', u'. /') self.assertThat(s.query(SearchEntry).count(), Equals(0)) SearchEntry.insert(s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type', u'yo') self.assertThat(s.query(SearchEntry).count(), Equals(1)) SearchEntry.insert(s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type', u'. /') self.assertThat(s.query(SearchEntry).count(), Equals(0)) s.transact(_tx)
def test_normalization(self, value): """ Inserting a value and then searching with a search equal to that value over normalization returns the inserted entry. """ assume(value != u'') s = Store() def _tx(): SearchEntry.insert( s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type', value) for mutation in [casefold, spaced, punctuated]: self.assertThat( list(SearchEntry.search( s, SearchClasses.EXACT, u'e', u'i', mutation(value))), Annotate( 'Not found for {!r}({!r}) == {!r}'.format( mutation, value, mutation(value)), Equals([u'RESULT']))) s.transact(_tx)
def testAttributeQueryMinMax(self): s = Store() def entesten(): E(store=s, amount=-4) E(store=s, amount=10) E(store=s, amount=99) E(store=s, amount=456) self.assertEquals(s.query(E).getColumn("amount").min(), -4) self.assertEquals(s.query(E).getColumn("amount").max(), 456) self.assertRaises(ValueError, s.query(D).getColumn("id").max) self.assertRaises(ValueError, s.query(D).getColumn("id").min) self.assertEquals(s.query(D).getColumn("id").min(default=41), 41) self.assertEquals(s.query(D).getColumn("id").max(default=42), 42) s.transact(entesten) s.close()
def test_searchEmpty(self): """ Searching for a value that is empty after normalization returns nothing. """ s = Store() def _tx(): SearchEntry.insert(s, SearchClasses.PREFIX, u'e', u'i', u'RESULT', u'type', u'yo') self.assertThat(s.query(SearchEntry).count(), Equals(1)) self.assertThat([ list( SearchEntry.search(s, SearchClasses.PREFIX, u'e', u'i', u'')), list( SearchEntry.search(s, SearchClasses.PREFIX, u'e', u'i', u'. .')) ], AllMatch(Equals([]))) s.transact(_tx)
def test_searchLimit(self): """ Searching does not return more results than the limit. """ s = Store() def _tx(): for x in xrange(50): SearchEntry.insert(s, SearchClasses.EXACT, u'e', u'i', u'RESULT', u'type{}'.format(x), u'yo') self.assertThat(s.query(SearchEntry).count(), Equals(50)) self.assertThat( list( SearchEntry.search(s, SearchClasses.EXACT, u'e', u'i', u'yo', limit=20)), HasLength(20)) s.transact(_tx)
def logInAndCheck(self, username, domain='localhost'): s = Store(self.mktemp()) def _speedup(): l = userbase.LoginSystem(store=s) l.installOn(s) s.checkpoint() p = Portal(IRealm(s), [ICredentialsChecker(s)]) a = l.addAccount(username, 'localhost', SECRET) gph = GarbageProtocolHandler(store=a.avatars.open(), garbage=0) gph.installOn(gph.store) return p, gph p, gph = s.transact(_speedup) def wasItGph((interface, avatar, logout)): self.assertEquals(interface, IGarbage) self.assertEquals(avatar, gph) logout() return p.login(UsernamePassword('bob@localhost', SECRET), None, IGarbage).addCallback(wasItGph)
class GenericNavigationAthenaPageTests(TestCase, AuthenticatedNavigationTestMixin): """ Tests for L{GenericNavigationAthenaPage}. """ def setUp(self): """ Set up a site store, user store, and page instance to test with. """ self.siteStore = Store(filesdir=self.mktemp()) def siteStoreTxn(): Mantissa().installSite(self.siteStore, u"localhost", u"", False) self.userStore = SubStore.createNew( self.siteStore, ['child', 'lookup']).open() self.siteStore.transact(siteStoreTxn) def userStoreTxn(): self.privateApp = PrivateApplication(store=self.userStore) installOn(self.privateApp, self.userStore) self.navpage = self.createPage(None) self.userStore.transact(userStoreTxn) def createPage(self, username): """ Create a L{GenericNavigationAthenaPage} for the given user. """ return GenericNavigationAthenaPage( self.privateApp, TestElement(), self.privateApp.getPageComponents(), username) def rootURL(self, request): """ Return the root URL as reported by C{self.website}. """ return ISiteURLGenerator(self.siteStore).rootURL(request) def test_childLookup(self): """ L{GenericNavigationAthenaPage} should delegate to its fragment and its L{LivePageFactory} when it cannot find a child itself. """ self.navpage.factory = tcf = TestClientFactory( 'client-of-livepage', 'I AM A CLIENT OF THE LIVEPAGE') self.assertEqual(self.navpage.locateChild(None, ('child-of-fragment',)), ('I AM A CHILD OF THE FRAGMENT', ())) self.assertEqual(self.navpage.locateChild(None, (tcf.magicSegment,)), (tcf.returnValue, ())) def test_jsModuleLocation(self): """ L{GenericNavigationAthenaPage.beforeRender} should should call L{xmantissa.website.MantissaLivePage.beforeRender}, which shares its Athena JavaScript module location with all other pages that use L{xmantissa.cachejs}, and provide links to /__jsmodule__/. """ ctx = WovenContext() req = FakeRequest() ctx.remember(req, IRequest) self.navpage.beforeRender(ctx) urlObj = self.navpage.getJSModuleURL('Mantissa') self.assertEqual(urlObj.pathList()[0], '__jsmodule__') def test_beforeRenderDelegation(self): """ L{GenericNavigationAthenaPage.beforeRender} should call C{beforeRender} on the wrapped fragment, if it's defined, and return its result. """ contexts = [] result = defer.succeed(None) def beforeRender(ctx): contexts.append(ctx) return result self.navpage.fragment.beforeRender = beforeRender ctx = WovenContext() ctx.remember(FakeRequest(), IRequest) self.assertIdentical( self.navpage.beforeRender(ctx), result) self.assertEqual(contexts, [ctx])
for ll in s.query(LendingLibrary): print 'found existing library' break else: print 'creating new library' ll = LendingLibrary(store=s) ll.initialize() ll.displayBooks() print '***' ll.shuffleLending() print '---' ll.displayBooks() print '***' ll.shuffleLending() print '---' print s.count( Book, AND(Book.author == u'Stephen King', Book.title == u'The Lions of al-Rassan')) print s.count( Book, OR(Book.author == u'Stephen King', Book.title == u'The Lions of al-Rassan')) if __name__ == '__main__': s = Store('testdb') s.transact(main, s) s.close()
class _PublicAthenaLivePageTestMixin(AuthenticatedNavigationTestMixin): """ Mixin which defines test methods which exercise functionality provided by the various L{xmantissa.publicweb._PublicPageMixin} subclasses, like L{PublicAthenaLivePage} and L{PublicNavAthenaLivePage}. """ signupURL = u'sign/up' signupPrompt = u'sign up now' def setUp(self): self.siteStore = Store(filesdir=self.mktemp()) def siteStoreTxn(): Mantissa().installSite(self.siteStore, self.userinfo[1], u"", False) ticketed = signup.FreeTicketSignup(store=self.siteStore, prefixURL=self.signupURL, prompt=self.signupPrompt) signup._SignupTracker(store=self.siteStore, signupItem=ticketed) return Create().addAccount(self.siteStore, self.userinfo[0], self.userinfo[1], u'password').avatars.open() self.userStore = self.siteStore.transact(siteStoreTxn) def userStoreTxn(): self.privateApp = PrivateApplication(store=self.userStore) installOn(self.privateApp, self.userStore) self.userStore.transact(userStoreTxn) def rootURL(self, request): """ Return the root URL as reported by C{self.website}. """ return ISiteURLGenerator(self.siteStore).rootURL(request) def test_unauthenticatedAuthenticateLinks(self): """ The I{authenticateLinks} renderer should add login and signup links to the tag it is passed, if it is called on a L{_PublicPageMixin} being rendered for an unauthenticated user. """ page = self.createPage(None) authenticateLinksPattern = div[span(pattern='signup-link')] ctx = context.WebContext(tag=authenticateLinksPattern) tag = page.render_authenticateLinks(ctx, None) self.assertEqual(tag.tagName, 'div') self.assertEqual(tag.attributes, {}) children = [child for child in tag.children if child.pattern is None] self.assertEqual(len(children), 1) self.assertEqual(children[0].slotData, { 'prompt': self.signupPrompt, 'url': '/' + self.signupURL }) def test_unauthenticatedStartmenu(self): """ The I{startmenu} renderer should remove the tag it is passed from the output if it is called on a L{_PublicPageMixin} being rendered for an unauthenticated user. """ page = self.createPage(None) startMenuTag = div() ctx = context.WebContext(tag=startMenuTag) tag = page.render_startmenu(ctx, None) self.assertEqual(tag, '') def test_unauthenticatedSettingsLink(self): """ The I{settingsLink} renderer should remove the tag it is passed from the output if it is called on a L{_PublicPageMixin} being rendered for an unauthenticated user. """ page = self.createPage(None) settingsLinkPattern = div() ctx = context.WebContext(tag=settingsLinkPattern) tag = page.render_settingsLink(ctx, None) self.assertEqual(tag, '') def test_unauthenticatedLogout(self): """ The I{logout} renderer should remove the tag it is passed from the output if it is called on a L{_PublicPageMixin} being rendered for an authenticated user. """ page = self.createPage(None) logoutPattern = div() ctx = context.WebContext(tag=logoutPattern) tag = page.render_logout(ctx, None) self.assertEqual(tag, '') def test_unauthenticatedApplicationNavigation(self): """ The I{applicationNavigation} renderer should remove the tag it is passed from the output if it is called on a L{_PublicPageMixin} being rendered for an unauthenticated user. """ page = self.createPage(None) navigationPattern = div() ctx = context.WebContext(tag=navigationPattern) tag = page.render_applicationNavigation(ctx, None) self.assertEqual(tag, '')
class ModelTest(unittest.TestCase): def setUp(self): self.store = Store() def _(): for x in range(107): X(store=self.store, number=x, textNumber=unicode(x), phoneticDigits=u' '.join(breakdown(str(x)))) self.store.transact(_) def assertNumbersAre(self, tdm, seq): self.assertEquals(list(x.get('number') for x in tdm.currentPage()), seq) def testUniformValues(self): for x in self.store.query(X): x.number = 1 tdm = tdb.TabularDataModel(self.store, X, [X.number], itemsPerPage=15) self.failUnless(tdm.hasNextPage(), 'expected there to be a next page') def testDeleteEverything(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) self.assertNumbersAre(tdm, range(15)) for item in self.store.query(X): item.deleteFromStore() self.assertNumbersAre(tdm, []) def testOnePage(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], AND(X.number >= 17, X.number < 94), itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) _assertNumbersAre(range(17, 17+15)) tdm.nextPage() _assertNumbersAre(range(17+15, 17+30)) tdm.firstPage() _assertNumbersAre(range(17, 17+15)) def testLeafing(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) _assertNumbersAre(range(15)) tdm.nextPage() _assertNumbersAre(range(15, 30)) tdm.prevPage() _assertNumbersAre(range(15)) tdm.lastPage() # This next assert is kind of weak, because it is valid to have only a # few results on the last page, but right now the strategy is to # always keep the page full of results. No matter what though, the # last page should contain the last value. self.assertEquals(list(tdm.currentPage())[-1]['number'], 106) tdm.firstPage() _assertNumbersAre(range(15)) def testLeafingAndSorting(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) _assertNumbersAre(range(15)) tdm.lastPage() _assertNumbersAre(range(107-15, 107)) tdm.prevPage() _assertNumbersAre(range(107-30, 107-15)) tdm.firstPage() _assertNumbersAre(range(15)) tdm.resort('number', False) tdm.firstPage() _assertNumbersAre(list(reversed(range(107-15, 107)))) tdm.lastPage() _assertNumbersAre(list(reversed(range(15)))) def testPageUnderrun(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) _assertNumbersAre(range(15)) # go to the pre-penultimate page for i in xrange(5): tdm.nextPage() _assertNumbersAre(range(15*5, (15*5)+15)) tdm.nextPage() lastFullSet = range(15*6, (15*6)+15) _assertNumbersAre(lastFullSet) tdm.nextPage() lastSet = [105, 106] _assertNumbersAre(lastSet) def testItemUnderrun(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=110) assertFirstPage = lambda: self.assertNumbersAre(tdm, range(107)) assertFirstPage() tdm.nextPage() assertFirstPage() tdm.prevPage() assertFirstPage() tdm.lastPage() assertFirstPage() tdm.firstPage() assertFirstPage() def testTwoPageNextLastEquality(self): tdm = tdb.TabularDataModel(self.store, X, [X.number], itemsPerPage=100) assertFirstPage = lambda: self.assertNumbersAre(tdm, range(100)) assertSecondPage = lambda: self.assertNumbersAre(tdm, range(100, 107)) assertFirstPage() tdm.nextPage() assertSecondPage() tdm.firstPage() assertFirstPage() tdm.lastPage() assertSecondPage() testTwoPageNextLastEquality.todo = 'is this a bug? it seems like one to me' def testPagination(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) self.assertEquals(tdm.pageNumber, 1) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 2) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 3) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 4) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 5) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 6) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 7) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 8) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.lastPage() self.assertEquals(tdm.pageNumber, 8) self.assertEquals(tdm.totalPages, 8) self.assertEquals(tdm.totalItems, 107) tdm.firstPage() self.assertEquals(tdm.pageNumber, 1) self.assertEquals(tdm.totalPages, 8) self.assertEquals(tdm.totalItems, 107) def testSortItemUnderrun(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=110) assertFirstPage = lambda: self.assertNumbersAre(tdm, range(107)) assertFirstPage() tdm.resort(tdm.currentSortColumn.attributeID) assertFirstPage() tdm.resort(tdm.currentSortColumn.attributeID, False) self.assertNumbersAre(tdm, list(reversed(range(107)))) tdm.resort(tdm.currentSortColumn.attributeID) assertFirstPage() tdm.resort(tdm.currentSortColumn.attributeID, True) assertFirstPage() def testChangeSortColumnItemUnderrun(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=110) assertFirstPage = lambda: self.assertNumbersAre(tdm, range(107)) assertFirstPage() tdm.resort(tdm.currentSortColumn.attributeID, True) assertFirstPage() # change sort direction, keep column tdm.resort(tdm.currentSortColumn.attributeID, False) self.assertNumbersAre(tdm, list(reversed(range(107)))) # change sort column and direction tdm.resort('phoneticDigits', True) # switch back to previous sort column & direction tdm.resort('number', False) self.assertNumbersAre(tdm, list(reversed(range(107)))) msg = 'itemsPerPage > totalItems, should only have one page' self.failIf(tdm.hasPrevPage(), msg) self.failIf(tdm.hasNextPage(), msg) def testOnePageHasNextPrev(self): bigtdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=200) bigtdm.nextPage() bigtdm.nextPage() self.failIf(bigtdm.hasNextPage()) self.failIf(bigtdm.hasPrevPage()) def testMultiPageHasNextPrev(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) self.failIf(tdm.hasPrevPage()) self.failUnless(tdm.hasNextPage()) tdm.nextPage() self.failUnless(tdm.hasNextPage()) self.failUnless(tdm.hasPrevPage()) tdm.prevPage() self.failIf(tdm.hasPrevPage()) self.failUnless(tdm.hasNextPage()) tdm.lastPage() self.failIf(tdm.hasNextPage()) self.failUnless(tdm.hasPrevPage()) tdm.prevPage() self.failUnless(tdm.hasNextPage()) self.failUnless(tdm.hasPrevPage()) tdm.firstPage() for x in range(6): tdm.nextPage() self.failUnless(tdm.hasPrevPage()) self.failUnless(tdm.hasNextPage()) tdm.nextPage() self.failUnless(tdm.hasPrevPage()) self.failIf(tdm.hasNextPage()) def testCurrentPageDoesntChange(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) for y in range(3): tdm.nextPage() example = tdm.currentPage() for x in range(3): self.assertEquals(example, tdm.currentPage()) def testDeleteItems(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) r = tdm.currentPage() r0 = r[0]['__item__'] r0.deleteFromStore() rx = tdm.currentPage() r1 = rx[0]['__item__'] self.failIf(r1._Item__deleting, "First item in current page was deleted!") r1.deleteFromStore() tdm.nextPage() self.assertNumbersAre(tdm, range(16, 16+15)) tdm.prevPage() self.assertNumbersAre(tdm, range(2, 2+15)) # The distinction between this test and the nextPage test above is # important: we never "skip" items when paging. The current results of # the TDM represent *what the user has seen*. In the previous case, we # have never called currentPage and received a result with #16 in it # before calling nextPage. In this case, assertNumbersAre(2,...) has # "seen" the page with #16 on it, so we are (correctly) taken to the # next item after that to begin the next page. tdm.nextPage() self.assertNumbersAre(tdm, range(17, 17+15)) def testSorting(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) tdm.resort('number', True) _assertNumbersAre(range(15)) tdm.resort('number', False) _assertNumbersAre(list(reversed(range(15)))) _assertNumbersAre(list(reversed(range(15)))) tdm.nextPage() _assertNumbersAre(list(reversed(range(15)))) def testUnsortableColumns(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, UnsortableColumn(X.textNumber), UnsortableColumn(X.phoneticDigits)], itemsPerPage=15) self.assertNumbersAre(tdm, range(15)) self.assertRaises(scrolltable.Unsortable, lambda: tdm.resort('textNumber')) self.assertRaises(scrolltable.Unsortable, lambda: tdm.resort('phoneticDigits')) # check to see if the last valid state remains self.assertNumbersAre(tdm, range(15))
print 'Lending', book.title, 'to', borrower book.lentTo = self.getBorrower(borrower) def main(s): for ll in s.query(LendingLibrary): print 'found existing library' break else: print 'creating new library' ll = LendingLibrary(store=s) ll.initialize() ll.displayBooks() print '***' ll.shuffleLending() print '---' ll.displayBooks() print '***' ll.shuffleLending() print '---' print s.count(Book, AND (Book.author == u'Stephen King', Book.title == u'The Lions of al-Rassan')) print s.count(Book, OR (Book.author == u'Stephen King', Book.title == u'The Lions of al-Rassan')) if __name__ == '__main__': s = Store('testdb') s.transact(main, s) s.close()
def testTupleQueryWithTuples(self): s = Store() s.transact(self._dotestTupleQueryWithTuples, s)
def main(): s = Store("TEMPORARY.axiom") benchmark.start() rows = [(x, str(x)) for x in range(10000)] s.transact(lambda: s.batchInsert(AB, (AB.a, AB.b), rows)) benchmark.stop()
class ModelTest(unittest.TestCase): def setUp(self): self.store = Store() def _(): for x in range(107): X(store=self.store, number=x, textNumber=unicode(x), phoneticDigits=u' '.join(breakdown(str(x)))) self.store.transact(_) def assertNumbersAre(self, tdm, seq): self.assertEquals(list(x.get('number') for x in tdm.currentPage()), seq) def testUniformValues(self): for x in self.store.query(X): x.number = 1 tdm = tdb.TabularDataModel(self.store, X, [X.number], itemsPerPage=15) self.failUnless(tdm.hasNextPage(), 'expected there to be a next page') def testDeleteEverything(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) self.assertNumbersAre(tdm, range(15)) for item in self.store.query(X): item.deleteFromStore() self.assertNumbersAre(tdm, []) def testOnePage(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], AND(X.number >= 17, X.number < 94), itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) _assertNumbersAre(range(17, 17 + 15)) tdm.nextPage() _assertNumbersAre(range(17 + 15, 17 + 30)) tdm.firstPage() _assertNumbersAre(range(17, 17 + 15)) def testLeafing(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) _assertNumbersAre(range(15)) tdm.nextPage() _assertNumbersAre(range(15, 30)) tdm.prevPage() _assertNumbersAre(range(15)) tdm.lastPage() # This next assert is kind of weak, because it is valid to have only a # few results on the last page, but right now the strategy is to # always keep the page full of results. No matter what though, the # last page should contain the last value. self.assertEquals(list(tdm.currentPage())[-1]['number'], 106) tdm.firstPage() _assertNumbersAre(range(15)) def testLeafingAndSorting(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) _assertNumbersAre(range(15)) tdm.lastPage() _assertNumbersAre(range(107 - 15, 107)) tdm.prevPage() _assertNumbersAre(range(107 - 30, 107 - 15)) tdm.firstPage() _assertNumbersAre(range(15)) tdm.resort('number', False) tdm.firstPage() _assertNumbersAre(list(reversed(range(107 - 15, 107)))) tdm.lastPage() _assertNumbersAre(list(reversed(range(15)))) def testPageUnderrun(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) _assertNumbersAre(range(15)) # go to the pre-penultimate page for i in xrange(5): tdm.nextPage() _assertNumbersAre(range(15 * 5, (15 * 5) + 15)) tdm.nextPage() lastFullSet = range(15 * 6, (15 * 6) + 15) _assertNumbersAre(lastFullSet) tdm.nextPage() lastSet = [105, 106] _assertNumbersAre(lastSet) def testItemUnderrun(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=110) assertFirstPage = lambda: self.assertNumbersAre(tdm, range(107)) assertFirstPage() tdm.nextPage() assertFirstPage() tdm.prevPage() assertFirstPage() tdm.lastPage() assertFirstPage() tdm.firstPage() assertFirstPage() def testTwoPageNextLastEquality(self): tdm = tdb.TabularDataModel(self.store, X, [X.number], itemsPerPage=100) assertFirstPage = lambda: self.assertNumbersAre(tdm, range(100)) assertSecondPage = lambda: self.assertNumbersAre(tdm, range(100, 107)) assertFirstPage() tdm.nextPage() assertSecondPage() tdm.firstPage() assertFirstPage() tdm.lastPage() assertSecondPage() testTwoPageNextLastEquality.todo = 'is this a bug? it seems like one to me' def testPagination(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) self.assertEquals(tdm.pageNumber, 1) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 2) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 3) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 4) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 5) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 6) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 7) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.nextPage() self.assertEquals(tdm.pageNumber, 8) self.assertEquals(tdm.totalItems, 107) self.assertEquals(tdm.totalPages, 8) tdm.lastPage() self.assertEquals(tdm.pageNumber, 8) self.assertEquals(tdm.totalPages, 8) self.assertEquals(tdm.totalItems, 107) tdm.firstPage() self.assertEquals(tdm.pageNumber, 1) self.assertEquals(tdm.totalPages, 8) self.assertEquals(tdm.totalItems, 107) def testSortItemUnderrun(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=110) assertFirstPage = lambda: self.assertNumbersAre(tdm, range(107)) assertFirstPage() tdm.resort(tdm.currentSortColumn.attributeID) assertFirstPage() tdm.resort(tdm.currentSortColumn.attributeID, False) self.assertNumbersAre(tdm, list(reversed(range(107)))) tdm.resort(tdm.currentSortColumn.attributeID) assertFirstPage() tdm.resort(tdm.currentSortColumn.attributeID, True) assertFirstPage() def testChangeSortColumnItemUnderrun(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=110) assertFirstPage = lambda: self.assertNumbersAre(tdm, range(107)) assertFirstPage() tdm.resort(tdm.currentSortColumn.attributeID, True) assertFirstPage() # change sort direction, keep column tdm.resort(tdm.currentSortColumn.attributeID, False) self.assertNumbersAre(tdm, list(reversed(range(107)))) # change sort column and direction tdm.resort('phoneticDigits', True) # switch back to previous sort column & direction tdm.resort('number', False) self.assertNumbersAre(tdm, list(reversed(range(107)))) msg = 'itemsPerPage > totalItems, should only have one page' self.failIf(tdm.hasPrevPage(), msg) self.failIf(tdm.hasNextPage(), msg) def testOnePageHasNextPrev(self): bigtdm = tdb.TabularDataModel( self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=200) bigtdm.nextPage() bigtdm.nextPage() self.failIf(bigtdm.hasNextPage()) self.failIf(bigtdm.hasPrevPage()) def testMultiPageHasNextPrev(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) self.failIf(tdm.hasPrevPage()) self.failUnless(tdm.hasNextPage()) tdm.nextPage() self.failUnless(tdm.hasNextPage()) self.failUnless(tdm.hasPrevPage()) tdm.prevPage() self.failIf(tdm.hasPrevPage()) self.failUnless(tdm.hasNextPage()) tdm.lastPage() self.failIf(tdm.hasNextPage()) self.failUnless(tdm.hasPrevPage()) tdm.prevPage() self.failUnless(tdm.hasNextPage()) self.failUnless(tdm.hasPrevPage()) tdm.firstPage() for x in range(6): tdm.nextPage() self.failUnless(tdm.hasPrevPage()) self.failUnless(tdm.hasNextPage()) tdm.nextPage() self.failUnless(tdm.hasPrevPage()) self.failIf(tdm.hasNextPage()) def testCurrentPageDoesntChange(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) for y in range(3): tdm.nextPage() example = tdm.currentPage() for x in range(3): self.assertEquals(example, tdm.currentPage()) def testDeleteItems(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) r = tdm.currentPage() r0 = r[0]['__item__'] r0.deleteFromStore() rx = tdm.currentPage() r1 = rx[0]['__item__'] self.failIf(r1._Item__deleting, "First item in current page was deleted!") r1.deleteFromStore() tdm.nextPage() self.assertNumbersAre(tdm, range(16, 16 + 15)) tdm.prevPage() self.assertNumbersAre(tdm, range(2, 2 + 15)) # The distinction between this test and the nextPage test above is # important: we never "skip" items when paging. The current results of # the TDM represent *what the user has seen*. In the previous case, we # have never called currentPage and received a result with #16 in it # before calling nextPage. In this case, assertNumbersAre(2,...) has # "seen" the page with #16 on it, so we are (correctly) taken to the # next item after that to begin the next page. tdm.nextPage() self.assertNumbersAre(tdm, range(17, 17 + 15)) def testSorting(self): tdm = tdb.TabularDataModel(self.store, X, [X.number, X.textNumber, X.phoneticDigits], itemsPerPage=15) _assertNumbersAre = lambda seq: self.assertNumbersAre(tdm, seq) tdm.resort('number', True) _assertNumbersAre(range(15)) tdm.resort('number', False) _assertNumbersAre(list(reversed(range(15)))) _assertNumbersAre(list(reversed(range(15)))) tdm.nextPage() _assertNumbersAre(list(reversed(range(15)))) def testUnsortableColumns(self): tdm = tdb.TabularDataModel(self.store, X, [ X.number, UnsortableColumn(X.textNumber), UnsortableColumn(X.phoneticDigits) ], itemsPerPage=15) self.assertNumbersAre(tdm, range(15)) self.assertRaises(scrolltable.Unsortable, lambda: tdm.resort('textNumber')) self.assertRaises(scrolltable.Unsortable, lambda: tdm.resort('phoneticDigits')) # check to see if the last valid state remains self.assertNumbersAre(tdm, range(15))
class _PublicAthenaLivePageTestMixin(AuthenticatedNavigationTestMixin): """ Mixin which defines test methods which exercise functionality provided by the various L{xmantissa.publicweb._PublicPageMixin} subclasses, like L{PublicAthenaLivePage} and L{PublicNavAthenaLivePage}. """ signupURL = u"sign/up" signupPrompt = u"sign up now" def setUp(self): self.siteStore = Store(filesdir=self.mktemp()) def siteStoreTxn(): Mantissa().installSite(self.siteStore, self.userinfo[1], u"", False) ticketed = signup.FreeTicketSignup(store=self.siteStore, prefixURL=self.signupURL, prompt=self.signupPrompt) signup._SignupTracker(store=self.siteStore, signupItem=ticketed) return Create().addAccount(self.siteStore, self.userinfo[0], self.userinfo[1], u"password").avatars.open() self.userStore = self.siteStore.transact(siteStoreTxn) def userStoreTxn(): self.privateApp = PrivateApplication(store=self.userStore) installOn(self.privateApp, self.userStore) self.userStore.transact(userStoreTxn) def rootURL(self, request): """ Return the root URL as reported by C{self.website}. """ return ISiteURLGenerator(self.siteStore).rootURL(request) def test_unauthenticatedAuthenticateLinks(self): """ The I{authenticateLinks} renderer should add login and signup links to the tag it is passed, if it is called on a L{_PublicPageMixin} being rendered for an unauthenticated user. """ page = self.createPage(None) authenticateLinksPattern = div[span(pattern="signup-link")] ctx = context.WebContext(tag=authenticateLinksPattern) tag = page.render_authenticateLinks(ctx, None) self.assertEqual(tag.tagName, "div") self.assertEqual(tag.attributes, {}) children = [child for child in tag.children if child.pattern is None] self.assertEqual(len(children), 1) self.assertEqual(children[0].slotData, {"prompt": self.signupPrompt, "url": "/" + self.signupURL}) def test_unauthenticatedStartmenu(self): """ The I{startmenu} renderer should remove the tag it is passed from the output if it is called on a L{_PublicPageMixin} being rendered for an unauthenticated user. """ page = self.createPage(None) startMenuTag = div() ctx = context.WebContext(tag=startMenuTag) tag = page.render_startmenu(ctx, None) self.assertEqual(tag, "") def test_unauthenticatedSettingsLink(self): """ The I{settingsLink} renderer should remove the tag it is passed from the output if it is called on a L{_PublicPageMixin} being rendered for an unauthenticated user. """ page = self.createPage(None) settingsLinkPattern = div() ctx = context.WebContext(tag=settingsLinkPattern) tag = page.render_settingsLink(ctx, None) self.assertEqual(tag, "") def test_unauthenticatedLogout(self): """ The I{logout} renderer should remove the tag it is passed from the output if it is called on a L{_PublicPageMixin} being rendered for an authenticated user. """ page = self.createPage(None) logoutPattern = div() ctx = context.WebContext(tag=logoutPattern) tag = page.render_logout(ctx, None) self.assertEqual(tag, "") def test_unauthenticatedApplicationNavigation(self): """ The I{applicationNavigation} renderer should remove the tag it is passed from the output if it is called on a L{_PublicPageMixin} being rendered for an unauthenticated user. """ page = self.createPage(None) navigationPattern = div() ctx = context.WebContext(tag=navigationPattern) tag = page.render_applicationNavigation(ctx, None) self.assertEqual(tag, "")
def testStringQueries(self): s = Store() def createAndStuff(): text1 = u'Hello, \u1234 world.' text2 = u'ThIs sTrInG iS nOt cAsE sEnSiTIvE. \u4567' bytes1 = '\x00, punk' x = ThingWithCharacterAndByteStrings( store=s, characterString=text1, caseInsensitiveCharString=text2, byteString=bytes1) x.checkpoint() q = list( s.query( ThingWithCharacterAndByteStrings, ThingWithCharacterAndByteStrings.characterString == text1.lower(), )) self.failIf(q, q) q = list( s.query( ThingWithCharacterAndByteStrings, ThingWithCharacterAndByteStrings.characterString == text1.upper(), )) self.failIf(q, q) q = list( s.query( ThingWithCharacterAndByteStrings, ThingWithCharacterAndByteStrings.characterString == text1, )) self.assertEquals(q, [x]) q = list( s.query( ThingWithCharacterAndByteStrings, ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2, )) self.assertEquals(q, [x]) q = list( s.query( ThingWithCharacterAndByteStrings, ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2.lower(), )) self.assertEquals(q, [x]) q = list( s.query( ThingWithCharacterAndByteStrings, ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2.upper(), )) self.assertEquals(q, [x]) q = list( s.query( ThingWithCharacterAndByteStrings, ThingWithCharacterAndByteStrings.byteString == bytes1, )) self.assertEquals(q, [x]) q = list( s.query( ThingWithCharacterAndByteStrings, ThingWithCharacterAndByteStrings.byteString == bytes1.upper(), )) self.failIf(q, q) s.transact(createAndStuff) s.close()
def testTupleQueryWithTuples(self): s = Store() s.transact(self._dotestTupleQueryWithTuples, s)