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)
