Commit ⋅ twisted/axiom

@@ -30,7 +30,6 @@

Loading

FAKE_POWER = 'fake power'
REAL_POWER = 'real power'


@implementer(IElectricityGrid)
class NullGrid(object):
    """

@@ -199,6 +198,7 @@

Loading




@dependency.dependable
@empowerment(IAppliance)
@empowerment(IBreadConsumer)
class Toaster(Item):

@@ -230,6 +230,9 @@

Loading


def powerstripSetup(ps):
    ps.setForUSElectricity()


@dependency.dependable
class Blender(Item):
    powerStrip = dependency.dependsOn(PowerStrip,
                                      powerstripSetup)

@@ -238,6 +241,8 @@

Loading

    def __getPowerupInterfaces__(self, powerups):
        yield (IAppliance, 0)


@dependency.dependable
class IceCrusher(Item):
    blender = dependency.dependsOn(Blender)


@@ -277,7 +282,7 @@

Loading

        """
        foo = Kitchen(store=self.store)
        e = Toaster(store=self.store)
        self.assertEquals(e.powerStrip, None)
        self.assertEqual(e.powerStrip, None)
        dependency.installOn(e, foo)
        e.toast()
        ps = self.store.findUnique(PowerStrip, default=None)

@@ -313,7 +318,7 @@

Loading

        dependency.installOn(e, foo)

        ps = self.store.findUnique(PowerStrip)
        self.failUnlessRaises(dependency.DependencyError,
        self.assertRaises(dependency.DependencyError,
                              dependency.uninstallFrom, ps, foo)

    def test_properOrphaning(self):

@@ -331,7 +336,7 @@

Loading

        f = Blender(store=self.store)
        dependency.installOn(f, foo)

        self.assertEquals(list(self.store.query(PowerStrip)), [ps])
        self.assertEqual(list(self.store.query(PowerStrip)), [ps])
        #XXX does ordering matter?
        self.assertEquals(set(dependency.installedDependents(ps, foo)),
                          {e, f})

@@ -341,10 +346,10 @@

Loading

                          [ps])

        dependency.uninstallFrom(e, foo)
        self.assertEquals(dependency.installedOn(ps), foo)
        self.assertEqual(dependency.installedOn(ps), foo)

        dependency.uninstallFrom(f, foo)
        self.assertEquals(dependency.installedOn(ps), None)
        self.assertEqual(dependency.installedOn(ps), None)

    def test_installedUniqueRequirements(self):
        """

@@ -359,7 +364,7 @@

Loading

        f = Blender(store=self.store)
        dependency.installOn(f, foo)

        self.assertEquals(list(dependency.installedUniqueRequirements(e, foo)),
        self.assertEqual(list(dependency.installedUniqueRequirements(e, foo)),
                          [bb])

    def test_customizerCalledOnce(self):

@@ -390,7 +395,7 @@

Loading

        dependency.installOn(e, foo)
        self.assertEqual(e.powerStrip, ps)
        dependency.uninstallFrom(e, foo)
        self.assertEquals(dependency.installedOn(ps), foo)
        self.assertEqual(dependency.installedOn(ps), foo)

    def test_doubleInstall(self):
        """

@@ -402,7 +407,7 @@

Loading

        e = Toaster(store=self.store)
        dependency.installOn(e, foo)
        ps = PowerStrip(store=self.store)
        self.failUnlessRaises(dependency.DependencyError,
        self.assertRaises(dependency.DependencyError,
                              dependency.installOn, ps, foo)
        e2 = Toaster(store=self.store)
        dependency.installOn(e2, foo)

@@ -419,9 +424,9 @@

Loading

        blender = self.store.findUnique(Blender)
        ps = self.store.findUnique(PowerStrip)

        self.assertEquals(dependency.installedOn(blender), foo)
        self.assertEquals(dependency.installedOn(ps), foo)
        self.assertEquals(list(dependency.installedRequirements(ic, foo)),
        self.assertEqual(dependency.installedOn(blender), foo)
        self.assertEqual(dependency.installedOn(ps), foo)
        self.assertEqual(list(dependency.installedRequirements(ic, foo)),
                          [blender])

    def test_recursiveUninstall(self):

@@ -437,9 +442,9 @@

Loading


        dependency.uninstallFrom(ic, foo)

        self.failIf(dependency.installedOn(blender))
        self.failIf(dependency.installedOn(ps))
        self.failIf(dependency.installedOn(ic))
        self.assertFalse(dependency.installedOn(blender))
        self.assertFalse(dependency.installedOn(ps))
        self.assertFalse(dependency.installedOn(ic))

    def test_wrongDependsOn(self):
        """

@@ -452,8 +457,8 @@

Loading

        dependsOn should accept (most of) attributes.reference's args.
        """

        self.failUnless("power source" in Toaster.powerStrip.doc)
        self.assertEquals(Toaster.breadFactory.whenDeleted, reference.CASCADE)
        self.assertTrue("power source" in Toaster.powerStrip.doc)
        self.assertEqual(Toaster.breadFactory.whenDeleted, reference.CASCADE)

    def test_powerupInterfaces(self):
        """

@@ -465,10 +470,10 @@

Loading

        f = Blender(store=self.store)
        dependency.installOn(e, foo)
        dependency.installOn(f, foo)
        self.assertEquals(IAppliance(foo), e)
        self.assertEquals(IBreadConsumer(foo), e)
        self.assertEqual(IAppliance(foo), e)
        self.assertEqual(IBreadConsumer(foo), e)
        dependency.uninstallFrom(e, foo)
        self.assertEquals(IAppliance(foo), f)
        self.assertEqual(IAppliance(foo), f)
        dependency.uninstallFrom(f, foo)
        self.assertRaises(TypeError, IAppliance, foo)


@@ -483,11 +488,11 @@

Loading

        self.installCallbackCalled = False
        e.callback = lambda _: setattr(self, 'installCallbackCalled', True)
        dependency.installOn(e, foo)
        self.failUnless(self.installCallbackCalled)
        self.assertTrue(self.installCallbackCalled)
        self.uninstallCallbackCalled = False
        e.callback = lambda _: setattr(self, 'uninstallCallbackCalled', True)
        dependency.uninstallFrom(e, foo)
        self.failUnless(self.uninstallCallbackCalled)
        self.assertTrue(self.uninstallCallbackCalled)


    def test_onlyInstallPowerups(self):

@@ -500,8 +505,8 @@

Loading

        f = Toaster(store=self.store)
        dependency.onlyInstallPowerups(e, foo)
        dependency.onlyInstallPowerups(f, foo)
        self.assertEquals(list(foo.powerupsFor(IBreadConsumer)), [e, f])
        self.assertEquals(list(self.store.query(
        self.assertEqual(list(foo.powerupsFor(IBreadConsumer)), [e, f])
        self.assertEqual(list(self.store.query(
                    dependency._DependencyConnector)), [])



@@ -525,7 +530,7 @@

Loading

        """
        dependency.installOn(RealGrid(store=self.store), self.store)
        substore = SubStore.createNew(self.store, ['sub']).open()
        self.assertEquals(PowerStrip(store=substore).draw(1), REAL_POWER)
        self.assertEqual(PowerStrip(store=substore).draw(1), REAL_POWER)


    def test_requiresFromSiteDefault(self):

@@ -536,8 +541,8 @@

Loading

        """
        substore = SubStore.createNew(self.store, ['sub']).open()
        ps = PowerStrip(store=substore)
        self.assertEquals(ps.draw(1), FAKE_POWER)
        self.assertEquals(ps.grid.siteStore, self.store)
        self.assertEqual(ps.draw(1), FAKE_POWER)
        self.assertEqual(ps.grid.siteStore, self.store)


    def test_requiresFromSiteInSiteStore(self):

@@ -563,11 +568,11 @@

Loading

        L{dependency.requiresFromSite}.
        """
        plant = PowerPlant(store=self.store)
        self.assertEquals(plant.grid.siteStore, self.store)
        self.assertEquals(plant.grid.draw(100), FAKE_POWER)
        self.assertEqual(plant.grid.siteStore, self.store)
        self.assertEqual(plant.grid.draw(100), FAKE_POWER)
        dependency.installOn(RealGrid(store=self.store), self.store)
        self.assertEquals(plant.grid.siteStore, self.store)
        self.assertEquals(plant.grid.draw(100), FAKE_POWER)
        self.assertEqual(plant.grid.siteStore, self.store)
        self.assertEqual(plant.grid.draw(100), FAKE_POWER)


    def test_requiresFromSiteNoDefault(self):

@@ -577,7 +582,7 @@

Loading

        """
        dependency.installOn(RealGrid(store=self.store), self.store)
        substore = SubStore.createNew(self.store, ['sub']).open()
        self.assertEquals(SpecifiedBadDefaults(store=substore).pump(),
        self.assertEqual(SpecifiedBadDefaults(store=substore).pump(),
                          REAL_POWER)



@@ -59,7 +59,7 @@

Loading

        upgradeExplicitOid(store)

        for substore in store.query(SubStore):
            print('Upgrading: {!r}'.format(substore))
            print(u'Upgrading: {!r}'.format(substore))
            self.upgradeStore(substore.open())

    def perform(self, store, count):

@@ -72,9 +72,9 @@

Loading


        try:
            self.upgradeStore(store)
            print('Upgrade complete')
            print(u'Upgrade complete')
        except errors.ItemUpgradeError as e:
            print('Upgrader error:')
            print(u'Upgrader error:')
            e.originalFailure.printTraceback(file=sys.stdout)
            print(self.errorMessageFormat % (
                e.oldType.typeName, e.storeID, e.oldType.schemaVersion,

@@ -236,15 +236,15 @@

Loading

        acc = None
        for acc in self.store.query(userbase.LoginMethod):
            if acc.domain is None:
                print(acc.localpart, end='')
                print(acc.localpart, end=u'')
            else:
                print(acc.localpart + '@' + acc.domain, end='')
                print(acc.localpart + u'@' + acc.domain, end=u'')
            if acc.account.disabled:
                print(' [DISABLED]')
                print(u' [DISABLED]')
            else:
                print()
                print(u'')
        if acc is None:
            print('No accounts')
            print(u'No accounts')




@@ -1,6 +1,8 @@

Loading

import six
# -*- test-case-name: axiom.test.test_slotmachine -*-

import six

hyper = super

_NOSLOT = object()

@@ -38,7 +38,7 @@

Loading


    def testSanity(self):
        store = Store()
        for i in xrange(self.ntimes):
        for i in range(self.ntimes):
            SimpleReferent(store=store, ref=Referee(store=store, topSecret=i))
            (referee,) = list(store.query(Referee))
            (referent,) = list(store.query(SimpleReferent))

@@ -223,7 +223,7 @@

Loading

        """
        store = Store()
        t = nonUpgradedItem(store=store)
        self.assertEquals(t.__legacy__, True)
        self.assertEqual(t.__legacy__, True)
        self.assertRaises(KeyError, store.objectCache.get, t.storeID)
        t2 = store.getItemByID(t.storeID)
        self.assertNotIdentical(t, t2)

@@ -279,7 +279,7 @@

Loading

        """


LOCAL, REMOTE = range(2)
LOCAL, REMOTE = list(range(2))
class IBatchProcessor(Interface):
    def addReliableListener(listener, style=LOCAL):
        """

@@ -27,9 +27,10 @@

Loading

        Shared part of file creation tests.
        """
        f = s.newFile('test', 'whatever.txt')
        f.write('crap')
        f.write(b'crap')

        def cb(fpath):
            self.assertEquals(fpath.open().read(), 'crap')
            self.assertEqual(fpath.open().read(), b'crap')

        return f.close().addCallback(cb)


@@ -70,7 +71,7 @@

Loading

        npath = self.mktemp()
        s = Store(spath)
        rel = s.newFile("test", "123")
        TEST_STR = "test 123"
        TEST_STR = b"test 123"

        def cb(fpath):
            fpath.setContent(TEST_STR)

@@ -83,7 +84,7 @@

Loading

            s2 = Store(npath)
            pti = list(s2.query(PathTesterItem))[0]

            self.assertEquals(pti.relpath.getContent(),
            self.assertEqual(pti.relpath.getContent(),
                              TEST_STR)

        return rel.close().addCallback(cb)

@@ -14,11 +14,14 @@

Loading

from axiom.item import Item
from axiom.attributes import reference, boolean, AND
from axiom.errors import ItemNotFound, DependencyError, UnsatisfiedRequirement
from six.moves import map
from six.moves import zip
import six
from six.moves import map, zip

#There is probably a cleaner way to do this.
_globalDependencyMap = {}
# There is probably a cleaner way to do this.
_globalDependencyMap = {
    # map depending-class: (depended-upon-class,
    # callable-to-customize-creation, reference-attribute)
}

def dependentsOf(cls):
    deps = _globalDependencyMap.get(cls, None)

@@ -60,24 +63,34 @@

Loading

        raise TypeError("dependsOn can be used only from a class definition.")
    ref = reference(reftype=itemType, doc=doc, indexed=indexed, allowNone=True,
                    whenDeleted=whenDeleted)
    if "__dependsOn_advice_data__" not in locals:
        addClassAdvisor(_dependsOn_advice)
    if "__dependsOn_advice_data__" not in locals and six.PY2:
        addClassAdvisor(dependable)
    locals.setdefault('__dependsOn_advice_data__', []).append(
    (itemType, itemCustomizer, ref))
        (itemType, itemCustomizer, ref)
    )
    return ref

def _dependsOn_advice(cls):

def dependable(cls):
    """
    Classes that use `dependsOn` in their bodies should be decorated with this
    as a class decorator, like so::

        @dependable
        class A(Item):
            b = dependsOn(B)
    """
    if cls in _globalDependencyMap:
        print("Double advising of %s. dependency map from first time: %s" % (
            cls, _globalDependencyMap[cls]))
        #bail if we end up here twice, somehow
        # bail if we end up here twice, somehow
        return cls
    for itemType, itemCustomizer, ref in cls.__dict__[
        '__dependsOn_advice_data__']:
        '__dependsOn_advice_data__'
    ]:
        classDependsOn(cls, itemType, itemCustomizer, ref)
    del cls.__dependsOn_advice_data__
    return cls


def classDependsOn(cls, itemType, itemCustomizer, ref):
    _globalDependencyMap.setdefault(cls, []).append(
        (itemType, itemCustomizer, ref))

@@ -119,7 +132,7 @@

Loading

        if (dc.installee.__class__ == self.__class__
            and self.__class__ in set(
            itertools.chain([blob[0][0] for blob in
                             _globalDependencyMap.values()]))):
                             list(_globalDependencyMap.values())]))):
            #Somebody got here before we did... let's punt
            raise DependencyError("An instance of %r is already "
                                  "installed on %r." % (self.__class__,

@@ -1,5 +1,5 @@

Loading


import operator, random
import operator, random, six

from twisted.trial.unittest import TestCase


@@ -71,12 +71,12 @@

Loading

        """
        s = Store()
        comparison = (A.reftoc == B.storeID)
        self.assertEquals(
        self.assertEqual(
            comparison.getQuery(s),
            '({}.[reftoc] = {}.oid)'.format(
                A.getTableName(s),
                B.getTableName(s)))
        self.assertEquals(comparison.getArgs(s), [])
        self.assertEqual(comparison.getArgs(s), [])


    def test_leftHandStoreIDComparison(self):

@@ -87,12 +87,12 @@

Loading

        """
        s = Store()
        comparison = (B.storeID == A.reftoc)
        self.assertEquals(
        self.assertEqual(
            comparison.getQuery(s),
            '({}.oid = {}.[reftoc])'.format(
                B.getTableName(s),
                A.getTableName(s)))
        self.assertEquals(comparison.getArgs(s), [])
        self.assertEqual(comparison.getArgs(s), [])


    def test_simplestQuery(self):

@@ -103,7 +103,7 @@

Loading

        s = Store()
        query = ItemQuery(s, A)
        sql, args = query._sqlAndArgs('SELECT', '*')
        self.assertEquals(
        self.assertEqual(
            sql,
            'SELECT * FROM {}'.format(A.getTableName(s)))
        self.assertEquals(args, [])

@@ -117,12 +117,12 @@

Loading

        s = Store()
        query = ItemQuery(s, E, E.amount == 0)
        sql, args = query._sqlAndArgs('SELECT', '*')
        self.assertEquals(
        self.assertEqual(
            sql,
            'SELECT * FROM {} WHERE ({}.[amount] = ?)'.format(
                E.getTableName(s),
                E.getTableName(s)))
        self.assertEquals(args, [0])
        self.assertEqual(args, [0])


    def test_simpleReferenceComparison(self):

@@ -133,13 +133,13 @@

Loading

        s = Store()
        query = ItemQuery(s, A, A.reftoc == A.storeID)
        sql, args = query._sqlAndArgs('SELECT', '*')
        self.assertEquals(
        self.assertEqual(
            sql,
            'SELECT * FROM {} WHERE ({}.[reftoc] = {}.oid)'.format(
                A.getTableName(s),
                A.getTableName(s),
                A.getTableName(s)))
        self.assertEquals(args, [])
        self.assertEqual(args, [])


    def test_reversedReferenceComparison(self):

@@ -151,13 +151,13 @@

Loading

        s = Store()
        query = ItemQuery(s, A, A.storeID == A.reftoc)
        sql, args = query._sqlAndArgs('SELECT', '*')
        self.assertEquals(
        self.assertEqual(
            sql,
            'SELECT * FROM {} WHERE ({}.oid = {}.[reftoc])'.format(
                A.getTableName(s),
                A.getTableName(s),
                A.getTableName(s)))
        self.assertEquals(args, [])
        self.assertEqual(args, [])


    def test_unionComparison(self):

@@ -169,7 +169,7 @@

Loading

        query = ItemQuery(s, A, AND(A.reftoc == B.storeID,
                                    B.cref == C.storeID))
        sql, args = query._sqlAndArgs('SELECT', '*')
        self.assertEquals(
        self.assertEqual(
            sql,
            'SELECT * FROM %s, %s, %s '
            'WHERE ((%s.[reftoc] = %s.oid) AND '

@@ -181,7 +181,7 @@

Loading

                B.getTableName(s),
                B.getTableName(s),
                C.getTableName(s)))
        self.assertEquals(args, [])
        self.assertEqual(args, [])


    def testBasicQuery(self):

@@ -189,41 +189,41 @@

Loading


        def entesten():
            c1 = C(store=s,
                   name=u'yes')
                   name='yes')

            c2 = C(store=s,
                   name=u'no')
                   name='no')

            A(store=s,
              reftoc=c1,
              type=u'testc')
              type='testc')

            A(store=s,
              reftoc=c2,
              type=u'testc')
              type='testc')

            A(store=s,
              reftoc=c1,
              type=u'testx')
              type='testx')

            yesb = B(store=s,
                     cref=c1,
                     name=u'correct')
                     name='correct')

            B(store=s,
              cref=c2,
              name=u'not correct')
              name='not correct')

            s.checkpoint()

            q = list(s.query(B,
                             AND(AND(C.name == u'yes',
                                     A.type == u'testc'),
                             AND(AND(C.name == 'yes',
                                     A.type == 'testc'),
                                 AND(C.storeID == B.cref,
                                     A.reftoc == C.storeID)),
                             ))

            self.assertEquals(q, [yesb])
            self.assertEqual(q, [yesb])

        s.transact(entesten)
        s.close()

@@ -235,7 +235,7 @@

Loading

        def createAndStuff():
            text1 = u'Hello, \u1234 world.'
            text2 = u'ThIs sTrInG iS nOt cAsE sEnSiTIvE.  \u4567'
            bytes1 = '\x00, punk'
            bytes1 = b'\x00, punk'

            x = ThingWithCharacterAndByteStrings(
                store=s,

@@ -249,55 +249,55 @@

Loading

                s.query(ThingWithCharacterAndByteStrings,
                        ThingWithCharacterAndByteStrings.characterString == text1.lower(),
                        ))
            self.failIf(q, q)
            self.assertFalse(q, q)

            q = list(
                s.query(ThingWithCharacterAndByteStrings,
                        ThingWithCharacterAndByteStrings.characterString == text1.upper(),
                        ))
            self.failIf(q, q)
            self.assertFalse(q, q)

            q = list(
                s.query(ThingWithCharacterAndByteStrings,
                        ThingWithCharacterAndByteStrings.characterString == text1,
                        ))

            self.assertEquals(q, [x])
            self.assertEqual(q, [x])

            q = list(
                s.query(ThingWithCharacterAndByteStrings,
                        ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2,
                        ))

            self.assertEquals(q, [x])
            self.assertEqual(q, [x])

            q = list(
                s.query(ThingWithCharacterAndByteStrings,
                        ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2.lower(),
                        ))

            self.assertEquals(q, [x])
            self.assertEqual(q, [x])

            q = list(
                s.query(ThingWithCharacterAndByteStrings,
                        ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2.upper(),
                        ))

            self.assertEquals(q, [x])
            self.assertEqual(q, [x])

            q = list(
                s.query(ThingWithCharacterAndByteStrings,
                        ThingWithCharacterAndByteStrings.byteString == bytes1,
                        ))

            self.assertEquals(q, [x])
            self.assertEqual(q, [x])

            q = list(
                s.query(ThingWithCharacterAndByteStrings,
                        ThingWithCharacterAndByteStrings.byteString == bytes1.upper(),
                        ))

            self.failIf(q, q)
            self.assertFalse(q, q)

        s.transact(createAndStuff)
        s.close()

@@ -306,27 +306,27 @@

Loading

    def testAggregateQueries(self):
        s = Store()
        def entesten():
            self.assertEquals(s.query(E).count(), 0)
            self.assertEquals(s.query(E).getColumn("amount").sum(), 0)
            self.assertEqual(s.query(E).count(), 0)
            self.assertEqual(s.query(E).getColumn("amount").sum(), 0)

            E(store=s, name=u'widgets', amount=37)
            E(store=s, name=u'widgets', amount=63)
            E(store=s, name=u'quatloos', amount=99, transaction=u'yes')
            E(store=s, name='widgets', amount=37)
            E(store=s, name='widgets', amount=63)
            E(store=s, name='quatloos', amount=99, transaction='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)
            q = s.count(E, E.name == 'widgets')
            self.assertEqual(q, 2)
            q = s.sum(E.amount, E.name == 'widgets')
            self.assertEqual(q, 100)
        s.transact(entesten)
        s.close()

    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")),
            E(store=s, name='b', amount=456)
            E(store=s, name='a', amount=123)
            E(store=s, name='c', amount=789)
            self.assertEqual(list(s.query(E, sort=E.name.ascending).getColumn("amount")),
                              [123, 456, 789])

        s.transact(entesten)

@@ -335,21 +335,21 @@

Loading

    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)
            E(store=s, name='a', amount=123)
            E(store=s, name='b', amount=456)
            E(store=s, name='c')  # no amount given
            self.assertEqual(s.query(E).getColumn("amount").count(), 2)
        s.transact(entesten)
        s.close()

    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"])
            E(store=s, name='a', amount=123)
            E(store=s, name='b', amount=789)
            E(store=s, name='a', amount=456)
            self.assertEqual(list(s.query(E, sort=E.name.ascending).getColumn("name").distinct()),
                              ["a", "b"])
        s.transact(entesten)
        s.close()


@@ -369,10 +369,10 @@

Loading

        """
        s = Store()
        def entesten():
            C(store=s, name=u'a')
            C(store=s, name=u'b')
            C(store=s, name='a')
            C(store=s, name='b')
            q = s.query(C, C.name != None).getColumn('name').distinct()
            self.assertEqual(sorted(q), [u'a', u'b'])
            self.assertEqual(sorted(q), ['a', 'b'])
        s.transact(entesten)
        s.close()


@@ -384,11 +384,11 @@

Loading

        """
        s = Store()
        def entesten():
            theC = C(store=s, name=u'it')
            theC = C(store=s, name='it')
            B(store=s, cref=theC)
            B(store=s, cref=theC)
            B(store=s, cref=theC)
            self.assertEquals(list(s.query(C, B.cref == C.storeID).distinct()),
            self.assertEqual(list(s.query(C, B.cref == C.storeID).distinct()),
                              [theC])
        s.transact(entesten)
        s.close()

@@ -401,11 +401,11 @@

Loading

        """
        s = Store()
        def entesten():
            for n, name in (2, u'it'), (3, u'indefinite nominative'):
            for n, name in (2, 'it'), (3, 'indefinite nominative'):
                theC = C(store=s, name=name)
                for i in range(n):
                    B(store=s, cref=theC)
            self.assertEquals(
            self.assertEqual(
                s.query(C, B.cref == C.storeID).distinct().count(),
                2)
        s.transact(entesten)

@@ -523,14 +523,14 @@

Loading

            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.assertEqual(s.query(E).getColumn("amount").min(), -4)
            self.assertEqual(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)
            self.assertEqual(s.query(D).getColumn("id").min(default=41), 41)
            self.assertEqual(s.query(D).getColumn("id").max(default=42), 42)


        s.transact(entesten)

@@ -596,26 +596,26 @@

Loading

        s = Store()
        def entesten():
            for i in range(3):
                c = C(store=s, name=u"C.%s" % i)
                B(store=s, name=u"B.%s" % (2-i), cref=c)
                c = C(store=s, name="C.%s" % i)
                B(store=s, name="B.%s" % (2-i), cref=c)

            query = s.query( (B, C),
                             B.cref == C.storeID,
                             sort=C.name.ascending)

            self.assertEquals(query.count(), 3)
            self.assertEqual(query.count(), 3)

            result = next(iter(query))

            self.assertEquals(len(result), 2)
            self.assertEqual(len(result), 2)

            b, c = result

            self.assertTrue(isinstance(b, B))
            self.assertTrue(isinstance(c, C))

            self.assertEquals(b.name, u"B.2")
            self.assertEquals(c.name, u"C.0")
            self.assertEqual(b.name, "B.2")
            self.assertEqual(c.name, "C.0")

        s.transact(entesten)
        s.close()

@@ -628,16 +628,16 @@

Loading

        s = Store()
        def entesten():
            for i in range(3):
                c = C(store=s, name=u"C.%s" % i)
                B(store=s, name=u"B.%s" % (2-i), cref=c)
                B(store=s, name=u"B2.%s" % (2-i), cref=c)
                c = C(store=s, name="C.%s" % i)
                B(store=s, name="B.%s" % (2-i), cref=c)
                B(store=s, name="B2.%s" % (2-i), cref=c)

            query = s.query( (B, C),
                             B.cref == C.storeID)

            totalCombinations = 6

            self.assertEquals(query.count(), totalCombinations)
            self.assertEqual(query.count(), totalCombinations)

            for offset in range(totalCombinations):
                for limit in range(totalCombinations + 1):

@@ -661,25 +661,25 @@

Loading

        s = Store()
        def entesten():
            for i in range(3):
                c = C(store=s, name=u"C.%s" % i)
                b = B(store=s, name=u"B.%s" % i, cref=c)
                A(store=s, type=u"A.%s" % i, reftoc=b)
                A(store=s, type=u"A.%s" % i, reftoc=b)
                c = C(store=s, name="C.%s" % i)
                b = B(store=s, name="B.%s" % i, cref=c)
                A(store=s, type="A.%s" % i, reftoc=b)
                A(store=s, type="A.%s" % i, reftoc=b)

            query = s.query( (B, C),
                             AND(B.cref == C.storeID,
                                 A.reftoc == B.storeID),
                             sort = C.name.ascending )

            self.assertEquals(query.count(), 6)
            self.assertEqual(query.count(), 6)

            distinct = query.distinct()

            self.assertEquals(distinct.count(), 3)
            self.assertEqual(distinct.count(), 3)

            for i, (b, c) in enumerate(query.distinct()):
                self.assertEquals(b.name, u"B.%s" % i)
                self.assertEquals(c.name, u"C.%s" % i)
                self.assertEqual(b.name, "B.%s" % i)
                self.assertEqual(c.name, "C.%s" % i)

        s.transact(entesten)
        s.close()

@@ -691,10 +691,10 @@

Loading

        """
        s = Store()
        def entesten():
            pops = B(store=s, name=u"Pops")
            dad = B(store=s, name=u"Dad", cref=pops)
            B(store=s, name=u"Bro", cref=dad)
            B(store=s, name=u"Sis", cref=dad)
            pops = B(store=s, name="Pops")
            dad = B(store=s, name="Dad", cref=pops)
            B(store=s, name="Bro", cref=dad)
            B(store=s, name="Sis", cref=dad)

            Gen1 = Placeholder(B)
            Gen2 = Placeholder(B)

@@ -705,7 +705,7 @@

Loading

                                 Gen2.cref == Gen1.storeID),
                             sort=Gen3.name.ascending )

            self.assertEquals(query.count(), 2)
            self.assertEqual(query.count(), 2)

            self.assertEquals(tuple(b.name for b in next(iter(query))),
                              (u"Pops", u"Dad", u"Bro"))

@@ -719,12 +719,12 @@

Loading

        s = Store()
        def entesten():
            for i in range(3):
                C(store=s, name=u"C.%s" % i)
                C(store=s, name="C.%s" % i)

            query = s.query( (C,),
                             sort=C.name.ascending)

            self.assertEquals(query.count(), 3)
            self.assertEqual(query.count(), 3)

            results = iter(query)


@@ -733,7 +733,7 @@

Loading

                self.assertEquals(len(result), 1)
                c, = result
                self.assertTrue(isinstance(c, C), "%s is not a C" % c)
                self.assertEquals(c.name, u"C.%s" % i, i)
                self.assertEqual(c.name, "C.%s" % i, i)

        s.transact(entesten)
        s.close()

@@ -846,9 +846,12 @@

Loading

    def setUp(self):
        s = self.store = Store()
        def _createStuff():
            self.d1 = D(store=s, one='d1.one', two='d1.two', three='d1.three', four=u'd1.four', id='1')
            self.d2 = D(store=s, one='d2.one', two='d2.two', three='d2.three', four=u'd2.four', id='2')
            self.d3 = D(store=s, one='d3.one', two='d3.two', three='d3.three', four=u'd3.four', id='3')
            self.d1 = D(store=s, one=b'd1.one', two=b'd1.two',
                        three=b'd1.three', four=u'd1.four', id=b'1')
            self.d2 = D(store=s, one=b'd2.one', two=b'd2.two',
                        three=b'd2.three', four=u'd2.four', id=b'2')
            self.d3 = D(store=s, one=b'd3.one', two=b'd3.two',
                        three=b'd3.three', four=u'd3.four', id=b'3')
        s.transact(_createStuff)

    def tearDown(self):

@@ -885,12 +888,12 @@

Loading

            args = []

        sql = query.getQuery(self.store)
        self.assertEquals(
        self.assertEqual(
            sql,
            expected,
            "\n%r != %r\n(if SQL generation code has changed, maybe this test "
            "should be updated)\n" % (sql, expected))
        self.assertEquals([str(a) for a in query.getArgs(self.store)], args)
        self.assertEqual([bytes(a) for a in query.getArgs(self.store)], args)




@@ -914,7 +917,7 @@

Loading

        only the table for the type being queried.
        """
        store = Store()
        query = store.query(A, A.type == u'value')
        query = store.query(A, A.type == 'value')
        self.assertEqual(query.fromClauseParts, [store.getTableName(A)])



@@ -947,7 +950,7 @@

Loading

        queried included in the FROM clause.
        """
        store = Store()
        query = store.query(A, A.type == u'value', sort=A.type.ascending)
        query = store.query(A, A.type == 'value', sort=A.type.ascending)
        self.assertEqual(query.fromClauseParts, [store.getTableName(A)])



@@ -959,7 +962,7 @@

Loading

        store = Store()
        self.assertRaises(
            ValueError,
            store.query, A, B.name == u'value')
            store.query, A, B.name == 'value')


    def test_invalidSort(self):

@@ -1038,14 +1041,14 @@

Loading

            OR(A.type == u'Narf!'),
            '(({} = ?))'.format(A.type.getColumnName(self.store)),
            ['Narf!'])
        self.assertEquals(self.query(D, AND(D.one == 'd1.one')), [self.d1])
        self.assertEquals(self.query(D, OR(D.one == 'd1.one')), [self.d1])
        self.assertEqual(self.query(D, AND(D.one == b'd1.one')), [self.d1])
        self.assertEqual(self.query(D, OR(D.one == b'd1.one')), [self.d1])


    def testMultipleAndConditions(self):
        condition = AND(A.type == u'Narf!',
                        A.type == u'Poiuyt!',
                        A.type == u'Try to take over the world')
        condition = AND(A.type == 'Narf!',
                        A.type == 'Poiuyt!',
                        A.type == 'Try to take over the world')

        expectedSQL = '((%s = ?) AND (%s = ?) AND (%s = ?))'
        expectedSQL %= (A.type.getColumnName(self.store),) * 3

@@ -1054,27 +1057,28 @@

Loading

            condition,
            expectedSQL,
            ['Narf!', 'Poiuyt!', 'Try to take over the world'])
        self.assertEquals(
            self.query(D, AND(D.one == 'd1.one',
                              D.two == 'd1.two',
                              D.three == 'd1.three')),
        self.assertEqual(
            self.query(D, AND(D.one == b'd1.one',
                              D.two == b'd1.two',
                              D.three == b'd1.three')),
            [self.d1])

    def testMultipleOrConditions(self):
        condition = OR(A.type == u'Narf!',
                       A.type == u'Poiuyt!',
                       A.type == u'Try to take over the world')
        condition = OR(A.type == 'Narf!',
                       A.type == 'Poiuyt!',
                       A.type == 'Try to take over the world')
        expectedSQL = '((%s = ?) OR (%s = ?) OR (%s = ?))'
        expectedSQL %= (A.type.getColumnName(self.store),) * 3
        self.assertQuery(
            condition,
            expectedSQL,
            ['Narf!', 'Poiuyt!', 'Try to take over the world'])
        q = self.query(D, OR(D.one == 'd1.one',
                             D.one == 'd2.one',
                             D.one == 'd3.one'))
        q = self.query(D, OR(D.one == b'd1.one',
                             D.one == b'd2.one',
                             D.one == b'd3.one'))
        e = [self.d1, self.d2, self.d3]
        self.assertEquals(sorted(q), sorted(e))
        self.assertEqual(sorted(q, key=lambda d: d.one),
                         sorted(e, key=lambda d: d.one))


class SetMembershipQuery(QueryingTestCase):

@@ -1084,10 +1088,10 @@

Loading

        Test that comparing an attribute for containment against a value set
        generates the appropriate SQL.
        """
        values = [u'a', u'b', u'c']
        values = ['a', 'b', 'c']
        comparison = C.name.oneOf(values)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(self.store),
            '{} IN (?, ?, ?)'.format(
                C.name.getColumnName(self.store)))

@@ -1103,13 +1107,13 @@

Loading

        """
        values = A.type
        comparison = C.name.oneOf(values)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(self.store),
            '{} IN ({})'.format(
                C.name.getColumnName(self.store),
                A.type.getColumnName(self.store)))
        self.assertEquals(
        self.assertEqual(
            comparison.getArgs(self.store),
            [])


@@ -1121,14 +1125,14 @@

Loading

        """
        subselect = self.store.query(A).getColumn('type')
        comparison = C.name.oneOf(subselect)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(self.store),
            '{} IN (SELECT {} FROM {})'.format(
                C.name.getColumnName(self.store),
                A.type.getColumnName(self.store),
                A.getTableName(self.store)))
        self.assertEquals(
        self.assertEqual(
            comparison.getArgs(self.store),
            [])


@@ -1139,15 +1143,15 @@

Loading

        subselect and make sure they come out of the C{getArgs} method
        properly.
        """
        value = '10'
        value = b'10'
        subselect = self.store.query(
            D,
            AND(D.id == value,
                D.four == C.name)).getColumn('one')

        comparison = C.name.oneOf(subselect)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(self.store),
            '{} IN (SELECT {} FROM {}, {} WHERE (({} = ?) AND ({} = {})))'.format(
                C.name.getColumnName(self.store),

@@ -1158,27 +1162,27 @@

Loading

                D.four.getColumnName(self.store),
                C.name.getColumnName(self.store)))
        self.assertEquals(
            list(map(str, comparison.getArgs(self.store))),
            list(comparison.getArgs(self.store)),
            [value])


    def testOneOfWithList(self):
        cx = C(store=self.store, name=u'x')
        C(store=self.store, name=u'y')
        cz = C(store=self.store, name=u'z')
        cx = C(store=self.store, name='x')
        C(store=self.store, name='y')
        cz = C(store=self.store, name='z')

        query = self.store.query(
            C, C.name.oneOf([u'x', u'z', u'a']), sort=C.name.ascending)
            C, C.name.oneOf(['x', 'z', 'a']), sort=C.name.ascending)

        self.assertEquals(list(query), [cx, cz])
        self.assertEqual(list(query), [cx, cz])


    def testOneOfWithSet(self):
        s = Store()

        cx = C(store=s, name=u'x')
        C(store=s, name=u'y')
        cz = C(store=s, name=u'z')
        cx = C(store=s, name='x')
        C(store=s, name='y')
        cz = C(store=s, name='z')

        self.assertEquals(list(s.query(C, C.name.oneOf({u'x', u'z', u'a'}), sort=C.name.ascending)),
                          [cx, cz])

@@ -1212,42 +1216,43 @@

Loading


    def testOneString(self):
        self.assertQuery(
            D.one.like('foobar%'),
            D.one.like(b'foobar%'),
            '({} LIKE (?))'.format(D.one.getColumnName(self.store)),
            ['foobar%'])
            [b'foobar%'])
        self.assertQuery(
            D.one.notLike('foobar%'),
            D.one.notLike(b'foobar%'),
            '({} NOT LIKE (?))'.format(D.one.getColumnName(self.store)),
            ['foobar%'])
        self.assertEquals(self.query(D, D.four.like(u'd1.four')), [self.d1])
        self.assertEquals(self.query(D, D.four.notLike(u'd%.four')), [])
            [b'foobar%'])
        self.assertEqual(self.query(D, D.four.like(u'd1.four')), [self.d1])
        self.assertEqual(self.query(D, D.four.notLike(u'd%.four')), [])

    def testOneColumn(self):
        self.assertQuery(
            D.one.like(D.two),
            '({} LIKE ({}))'.format(D.one.getColumnName(self.store),
                                D.two.getColumnName(self.store)))
        self.assertEquals(self.query(D, D.one.like(D.two)), [])
        self.assertEqual(self.query(D, D.one.like(D.two)), [])

    def testOneColumnAndStrings(self):
        self.assertQuery(
            D.four.like(u'%', D.id, u'%four'),
            '({} LIKE (? || {} || ?))'.format(D.four.getColumnName(self.store),
                                          D.id.getColumnName(self.store)),
            [u'%', u'%four'])
        q = self.query(D, D.four.like(u'%', D.id, u'%four'))
            ['%', '%four'])
        q = self.query(D, D.four.like('%', D.id, '%four'))
        e = [self.d1, self.d2, self.d3]
        self.assertEquals(sorted(q), sorted(e))
        self.assertEqual(sorted(q, key=lambda d: d.id),
                         sorted(e, key=lambda d: d.id))

    def testMultipleColumns(self):
        self.assertQuery(
            D.one.like(D.two, '%', D.three),
            D.one.like(D.two, b'%', D.three),
            '({} LIKE ({} || ? || {}))'.format(D.one.getColumnName(self.store),
                                           D.two.getColumnName(self.store),
                                           D.three.getColumnName(self.store)),
            ['%'])
        self.assertEquals(
            self.query(D, D.one.like(D.two, '%', D.three)), [])
            [b'%'])
        self.assertEqual(
            self.query(D, D.one.like(D.two, b'%', D.three)), [])


    def testStartsEndsWith(self):

@@ -1259,18 +1264,18 @@

Loading

            D.four.endswith(u'foo'),
            '({} LIKE (?))'.format(D.four.getColumnName(self.store)),
            ['%foo'])
        self.assertEquals(
            self.query(D, D.four.startswith(u'd1')), [self.d1])
        self.assertEquals(
            self.query(D, D.four.endswith(u'3.four')), [self.d3])
        self.assertEqual(
            self.query(D, D.four.startswith('d1')), [self.d1])
        self.assertEqual(
            self.query(D, D.four.endswith('3.four')), [self.d3])


    def testStartsEndsWithText(self):
        self.assertEquals(
            self.query(D, D.four.startswith(u'd1')),
        self.assertEqual(
            self.query(D, D.four.startswith('d1')),
            [self.d1])
        self.assertEquals(
            self.query(D, D.four.endswith(u'2.four')),
        self.assertEqual(
            self.query(D, D.four.endswith('2.four')),
            [self.d2])



@@ -1279,26 +1284,26 @@

Loading


    def setUp(self):
        s = self.s = Store()
        self.c = C(store=s, name=u'unique')
        self.dupc1 = C(store=s, name=u'non-unique')
        self.dupc2 = C(store=s, name=u'non-unique')
        self.c = C(store=s, name='unique')
        self.dupc1 = C(store=s, name='non-unique')
        self.dupc2 = C(store=s, name='non-unique')

    def testUniqueFound(self):
        self.assertEquals(self.s.findUnique(C, C.name == u'unique'), self.c)
        self.assertEqual(self.s.findUnique(C, C.name == 'unique'), self.c)

    def testUniqueNotFoundError(self):
        self.assertRaises(errors.ItemNotFound, self.s.findUnique,
                          C, C.name == u'non-existent')
                          C, C.name == 'non-existent')

    def testUniqueNotFoundDefault(self):
        bing = object()
        self.assertEquals(bing, self.s.findUnique(
                C, C.name == u'non-existent',
        self.assertEqual(bing, self.s.findUnique(
                C, C.name == 'non-existent',
                default=bing))

    def testUniqueDuplicate(self):
        self.assertRaises(errors.DuplicateUniqueItem,
                          self.s.findUnique, C, C.name == u'non-unique')
                          self.s.findUnique, C, C.name == 'non-unique')




@@ -1336,7 +1341,7 @@

Loading

        """
        s = Store()
        p = Placeholder(PlaceholderTestItem)
        self.assertEquals(p.getTableName(s), PlaceholderTestItem.getTableName(s))
        self.assertEqual(p.getTableName(s), PlaceholderTestItem.getTableName(s))


    def test_placeholderColumnInterface(self):

@@ -1345,7 +1350,7 @@

Loading

        """
        p = Placeholder(PlaceholderTestItem)
        a = p.attr
        self.failUnless(IColumn.providedBy(a))
        self.assertTrue(IColumn.providedBy(a))


    def test_placeholderAttributeValueComparison(self):

@@ -1357,8 +1362,8 @@

Loading

        value = 0
        p = Placeholder(PlaceholderTestItem)
        for op in COMPARISON_OPS:
            self.failUnless(IComparison.providedBy(op(p.attr, value)))
            self.failUnless(IComparison.providedBy(op(value, p.attr)))
            self.assertTrue(IComparison.providedBy(op(p.attr, value)))
            self.assertTrue(IComparison.providedBy(op(value, p.attr)))


    def test_placeholderAttributeColumnComparison(self):

@@ -1369,13 +1374,13 @@

Loading

        """
        p = Placeholder(PlaceholderTestItem)
        for op in COMPARISON_OPS:
            self.failUnless(IComparison.providedBy(op(p.attr, PlaceholderTestItem.attr)))
            self.failUnless(IComparison.providedBy(op(PlaceholderTestItem.attr, p.attr)))
            self.assertTrue(IComparison.providedBy(op(p.attr, PlaceholderTestItem.attr)))
            self.assertTrue(IComparison.providedBy(op(PlaceholderTestItem.attr, p.attr)))


    def _placeholderAttributeSimilarity(self, kind, sql, args):
        s = Store()
        value = u'text'
        value = 'text'

        p = Placeholder(PlaceholderTestItem)


@@ -1383,10 +1388,10 @@

Loading

        p.getTableAlias(s, ())

        comparison = getattr(p.characters, kind)(value)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(comparison.getQuery(s),
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(comparison.getQuery(s),
                          sql % (p.characters.getColumnName(s),))
        self.assertEquals(
        self.assertEqual(
            comparison.getArgs(s),
            [args % (value,)])


@@ -1433,8 +1438,8 @@

Loading

        p.getTableAlias(s, ())

        comparison = PlaceholderTestItem.attr.like(p.attr)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(s),
            '({} LIKE (placeholder_0.[attr]))'.format(
                PlaceholderTestItem.attr.getColumnName(s)))

@@ -1456,8 +1461,8 @@

Loading

        p.getTableAlias(s, ())

        comparison = p.attr.oneOf(value)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(s),
            '{} IN (?, ?, ?)'.format(p.attr.getColumnName(s)))
        self.assertEquals(

@@ -1478,8 +1483,8 @@

Loading

        p.getTableAlias(s, ())

        comparison = p.attr.notOneOf(value)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(s),
            '{} NOT IN (?, ?, ?)'.format(p.attr.getColumnName(s)))
        self.assertEquals(

@@ -1499,12 +1504,12 @@

Loading

        p.getTableAlias(s, ())

        comparison = PlaceholderTestItem.attr.oneOf(p.attr)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(s),
            '{} IN ({})'.format(PlaceholderTestItem.attr.getColumnName(s),
                            p.attr.getColumnName(s)))
        self.assertEquals(
        self.assertEqual(
            comparison.getArgs(s),
            [])


@@ -1521,12 +1526,12 @@

Loading

        p.getTableAlias(s, ())

        comparison = PlaceholderTestItem.attr.notOneOf(p.attr)
        self.failUnless(IComparison.providedBy(comparison))
        self.assertEquals(
        self.assertTrue(IComparison.providedBy(comparison))
        self.assertEqual(
            comparison.getQuery(s),
            '{} NOT IN ({})'.format(PlaceholderTestItem.attr.getColumnName(s),
                            p.attr.getColumnName(s)))
        self.assertEquals(
        self.assertEqual(
            comparison.getArgs(s),
            [])


@@ -1538,7 +1543,7 @@

Loading

        """
        value = 0
        p = Placeholder(PlaceholderTestItem)
        self.failUnless(IComparison.providedBy(p.storeID > value))
        self.assertTrue(IComparison.providedBy(p.storeID > value))


    def test_placeholderAttributeError(self):

@@ -1564,7 +1569,7 @@

Loading

        theTable = next(iter(involvedTables))
        self.assertEquals(theTable.getTableName(s),
                          PlaceholderTestItem.getTableName(s))
        self.assertEquals(theTable.getTableAlias(s, ()),
        self.assertEqual(theTable.getTableAlias(s, ()),
                          'placeholder_0')



@@ -1583,10 +1588,10 @@

Loading


        value = 0
        comparison = (p.attr > value)
        self.assertEquals(
        self.assertEqual(
            comparison.getQuery(s),
            '(placeholder_0.[attr] > ?)')
        self.assertEquals(
        self.assertEqual(
            comparison.getArgs(s),
            [value])


@@ -1601,7 +1606,7 @@

Loading

        p = Placeholder(PlaceholderTestItem)
        value = 0
        args = (p.attr > value).getArgs(s)
        self.assertEquals(args, [0])
        self.assertEqual(args, [0])


    def test_placeholderQuery(self):

@@ -1612,7 +1617,7 @@

Loading

        s = Store()
        p = Placeholder(PlaceholderTestItem)
        sql, args = ItemQuery(s, p)._sqlAndArgs('SELECT', '*')
        self.assertEquals(
        self.assertEqual(
            sql,
            'SELECT * FROM {} AS placeholder_0'.format(
                PlaceholderTestItem.getTableName(s)))

@@ -1647,7 +1652,7 @@

Loading

            PlaceholderTestItem,
            PlaceholderTestItem.attr == p.attr)
        sql, args = query._sqlAndArgs('SELECT', '*')
        self.assertEquals(
        self.assertEqual(
            sql,
            'SELECT * '
            'FROM %s, %s AS placeholder_0 '

@@ -1655,7 +1660,7 @@

Loading

                PlaceholderTestItem.getTableName(s),
                PlaceholderTestItem.getTableName(s),
                PlaceholderTestItem.getTableName(s)))
        self.assertEquals(args, [])
        self.assertEqual(args, [])


    def test_placeholderOrdering(self):

@@ -1665,14 +1670,14 @@

Loading

        """
        p1 = Placeholder(PlaceholderTestItem)
        p2 = Placeholder(PlaceholderTestItem)
        self.failUnless(p1 < p2)
        self.failUnless(p2 > p1)
        self.failIf(p1 >= p2)
        self.failIf(p2 <= p1)
        self.failIf(p1 == p2)
        self.failIf(p2 == p1)
        self.failUnless(p1 != p2)
        self.failUnless(p2 != p1)
        self.assertTrue(p1 < p2)
        self.assertTrue(p2 > p1)
        self.assertFalse(p1 >= p2)
        self.assertFalse(p2 <= p1)
        self.assertFalse(p1 == p2)
        self.assertFalse(p2 == p1)
        self.assertTrue(p1 != p2)
        self.assertTrue(p2 != p1)


    def test_placeholderObjectSorting(self):

@@ -1680,11 +1685,11 @@

Loading

        Placeholders should sort based on the order in which they were
        instantiated.
        """
        placeholders = [Placeholder(PlaceholderTestItem) for n in xrange(10)]
        placeholders = [Placeholder(PlaceholderTestItem) for n in range(10)]
        shuffledPlaceholders = list(placeholders)
        random.shuffle(shuffledPlaceholders)
        shuffledPlaceholders.sort()
        self.assertEquals(placeholders, shuffledPlaceholders)
        self.assertEqual(placeholders, shuffledPlaceholders)


    def test_placeholderAliasAssignment(self):

@@ -1696,11 +1701,11 @@

Loading

        p2 = Placeholder(PlaceholderTestItem)

        aliases = []
        self.assertEquals(p1.getTableAlias(s, aliases), 'placeholder_0')
        self.assertEquals(p1.getTableAlias(s, aliases), 'placeholder_0')
        self.assertEqual(p1.getTableAlias(s, aliases), 'placeholder_0')
        self.assertEqual(p1.getTableAlias(s, aliases), 'placeholder_0')
        aliases.append('placeholder_')
        self.assertEquals(p1.getTableAlias(s, aliases), 'placeholder_0')
        self.assertEquals(p2.getTableAlias(s, aliases), 'placeholder_1')
        self.assertEqual(p1.getTableAlias(s, aliases), 'placeholder_0')
        self.assertEqual(p2.getTableAlias(s, aliases), 'placeholder_1')


    def test_multiplePlaceholderComparisons(self):

@@ -1720,7 +1725,7 @@

Loading

                PlaceholderTestItem.attr == p2.attr,
                PlaceholderTestItem.characters == p2.characters))
        sql, args = query._sqlAndArgs('SELECT', '*')
        self.assertEquals(
        self.assertEqual(
            sql,
            'SELECT * '
            'FROM %s, %s AS placeholder_0, %s AS placeholder_1 '

@@ -1735,7 +1740,7 @@

Loading

                PlaceholderTestItem.other.getColumnName(s),
                PlaceholderTestItem.attr.getColumnName(s),
                PlaceholderTestItem.characters.getColumnName(s)))
        self.assertEquals(args, [])
        self.assertEqual(args, [])


    def test_sortByPlaceholderAttribute(self):

@@ -1756,8 +1761,8 @@

Loading

                       'ORDER BY placeholder_0.[attr] ASC')
        expectedSQL %= (p.getTableName(s),)

        self.assertEquals(sql, expectedSQL)
        self.assertEquals(args, [])
        self.assertEqual(sql, expectedSQL)
        self.assertEqual(args, [])


    def test_placeholderColumnNamesInQueryTarget(self):

@@ -1772,7 +1777,11 @@

Loading


        expectedSQL = "placeholder_0.oid, placeholder_0.[attr], placeholder_0.[characters], placeholder_0.[other]"

        self.assertEquals(query._queryTarget, expectedSQL)
        self.assertEqual(query._queryTarget, expectedSQL)



bytes_deprecated_prefix = 'axiom.attributes.bytes.' if six.PY3 else 'axiom.attributes.'




@@ -1783,7 +1792,7 @@

Loading

    def test_startsWith(self):
        self.assertWarns(
            DeprecationWarning,
            'axiom.attributes.startswith was deprecated in Axiom 0.7.5',
            bytes_deprecated_prefix + 'startswith was deprecated in Axiom 0.7.5',
            __file__,
            lambda: D.one.startswith('string'))


@@ -1791,7 +1800,7 @@

Loading

    def test_endsWith(self):
        self.assertWarns(
            DeprecationWarning,
            'axiom.attributes.endswith was deprecated in Axiom 0.7.5',
            bytes_deprecated_prefix + 'endswith was deprecated in Axiom 0.7.5',
            __file__,
            lambda: D.one.endswith('string'))


@@ -1799,7 +1808,7 @@

Loading

    def test_like(self):
        self.assertWarns(
            DeprecationWarning,
            'axiom.attributes.like was deprecated in Axiom 0.7.5',
            bytes_deprecated_prefix + 'like was deprecated in Axiom 0.7.5',
            __file__,
            lambda: D.one.like('string'))


@@ -1807,6 +1816,6 @@

Loading

    def test_notLike(self):
        self.assertWarns(
            DeprecationWarning,
            'axiom.attributes.notLike was deprecated in Axiom 0.7.5',
            bytes_deprecated_prefix + 'notLike was deprecated in Axiom 0.7.5',
            __file__,
            lambda: D.one.notLike('string'))

@@ -48,9 +48,9 @@

Loading

    def testSanity(self):
        xyz = XYZ()
        val = xyz.m()
        self.assertEquals(val, 3)
        self.assertEqual(val, 3)

    def testItemSanity(self):
        xyz = ItemXYZ()
        val = xyz.m()
        self.assertEquals(val, 3)
        self.assertEqual(val, 3)

@@ -77,10 +77,10 @@

Loading

        s2 = store.Store(storedir)
        a1 = A(store=s1)
        a2 = A(store=s2)
        self.assertEquals(list(s1.query(
        self.assertEqual(list(s1.query(
                    A, sort=A.storeID.ascending).getColumn("storeID")),
                          [a1.storeID, a2.storeID])
        self.assertEquals(list(s2.query(
        self.assertEqual(list(s2.query(
                    A, sort=A.storeID.ascending).getColumn("storeID")),
                          [a1.storeID, a2.storeID])


@@ -33,18 +33,18 @@

Loading

        s = Store()
        Number(store=s, value=7.1)
        n = s.findFirst(Number)
        self.assertEquals(n.value, 7.1)
        self.assertEqual(n.value, 7.1)

    def testFPSumsAreBrokenSoDontUseThem(self):
        s = Store()
        for x in range(10):
            Number(store=s,
                   value=0.1)
        self.assertNotEquals(s.query(Number).getColumn("value").sum(),
        self.assertNotEqual(s.query(Number).getColumn("value").sum(),
                             1.0)

        # This isn't really a unit test.  It's documentation.
        self.assertEquals(s.query(Number).getColumn("value").sum(),
        self.assertEqual(s.query(Number).getColumn("value").sum(),
                          0.99999999999999989)



@@ -70,15 +70,15 @@

Loading

        A Python int roundtrips through an integer attribute.
        """
        i = _Integer(store=self.store, value=42)
        self.assertEquals(i.value, 42)
        self.assertEqual(i.value, 42)


    def test_roundtripLong(self):
        """
        A Python long roundtrips through an integer attribute.
        """
        i = _Integer(store=self.store, value=42L)
        self.assertEquals(i.value, 42)
        i = _Integer(store=self.store, value=42)
        self.assertEqual(i.value, 42)


    def test_magnitudeBound(self):

@@ -107,7 +107,7 @@

Loading

        for x in range(10):
            DecimalDoodad(store=s,
                          money=Decimal("0.10"))
        self.assertEquals(s.query(DecimalDoodad).getColumn("money").sum(),
        self.assertEqual(s.query(DecimalDoodad).getColumn("money").sum(),
                          1)

    def testRoundTrip(self):

@@ -116,28 +116,28 @@

Loading

                      money=Decimal("4.3"),
                      otherMoney=Decimal("-17.94"))
        gc.collect() # Force the item to be reloaded from the database
        self.assertEquals(s.findFirst(DecimalDoodad).integral, 19947)
        self.assertEquals(s.findFirst(DecimalDoodad).money, Decimal("4.3"))
        self.assertEquals(s.findFirst(DecimalDoodad).otherMoney, Decimal("-17.9400"))
        self.assertEqual(s.findFirst(DecimalDoodad).integral, 19947)
        self.assertEqual(s.findFirst(DecimalDoodad).money, Decimal("4.3"))
        self.assertEqual(s.findFirst(DecimalDoodad).otherMoney, Decimal("-17.9400"))

    def testComparisons(self):
        s = Store()
        DecimalDoodad(store=s,
                      money=Decimal("19947.000000"),
                      otherMoney=19947)
        self.assertEquals(
        self.assertEqual(
            s.query(DecimalDoodad,
                    DecimalDoodad.money == DecimalDoodad.otherMoney).count(),
            1)
        self.assertEquals(
        self.assertEqual(
            s.query(DecimalDoodad,
                    DecimalDoodad.money != DecimalDoodad.otherMoney).count(),
            0)
        self.assertEquals(
        self.assertEqual(
            s.query(DecimalDoodad,
                    DecimalDoodad.money == 19947).count(),
            1)
        self.assertEquals(
        self.assertEqual(
            s.query(DecimalDoodad,
                    DecimalDoodad.money == Decimal("19947")).count(),
            1)

@@ -178,7 +178,7 @@

Loading

        sid = Number(store=s, value=1.0).storeID
        self.assertRaises(TypeError, s.getItemByID, str(sid))
        self.assertRaises(TypeError, s.getItemByID, float(sid))
        self.assertRaises(TypeError, s.getItemByID, unicode(sid))
        self.assertRaises(TypeError, s.getItemByID, str(sid))

class SortedItem(Item):
    typeName = 'test_sorted_thing'

@@ -193,7 +193,7 @@

Loading

    def testCompoundSort(self):
        s = Store()
        L = []
        r10 = range(10)
        r10 = list(range(10))
        random.shuffle(r10)
        L.append(SortedItem(store=s,
                            goingUp=0,

@@ -216,15 +216,15 @@

Loading

            ascsort = [getattr(SortedItem, colnm).ascending for colnm in colnms]
            descsort = [getattr(SortedItem, colnm).descending for colnm in colnms]

            self.assertEquals(LN, list(s.query(SortedItem,
            self.assertEqual(LN, list(s.query(SortedItem,
                                               sort=ascsort)))
            LN.reverse()
            self.assertEquals(LN, list(s.query(SortedItem,
            self.assertEqual(LN, list(s.query(SortedItem,
                                               sort=descsort)))


class FunkyItem(Item):
    name = unicode()
    name = str()

class BadAttributeTest(TestCase):


@@ -233,9 +233,9 @@

Loading

        L{Item} should not allow setting undeclared attributes.
        """
        s = Store()
        err = self.failUnlessRaises(AttributeError,
                                    FunkyItem, store=s, name=u"foo")
        self.assertEquals(str(err), "'FunkyItem' can't set attribute 'name'")
        err = self.assertRaises(AttributeError,
                                    FunkyItem, store=s, name="foo")
        self.assertEqual(str(err), "'FunkyItem' can't set attribute 'name'")




@@ -276,13 +276,13 @@

Loading

    def testTimestampDefault(self):
        s = Store()
        sid = DatedThing(store=s).storeID
        self.assertEquals(s.getItemByID(sid).date,
        self.assertEqual(s.getItemByID(sid).date,
                          someRandomDate)

    def testTimestampNow(self):
        s = Store()
        sid = CreationDatedThing(store=s).storeID
        self.failUnless(
        self.assertTrue(
            (Time().asDatetime() - s.getItemByID(sid).creationDate.asDatetime()).seconds <
            10)


@@ -301,20 +301,20 @@

Loading

        """
        s = Store()
        tlt = TaggedListyThing(store=s, strlist=value)
        self.assertEquals(tlt.strlist, value)
        self.assertEqual(tlt.strlist, value)

        # Force it out of the cache, so it gets reloaded from the store
        del tlt
        gc.collect()
        tlt = s.findUnique(TaggedListyThing)
        self.assertEquals(tlt.strlist, value)
        self.assertEqual(tlt.strlist, value)


    def test_simpleListOfStrings(self):
        """
        Test that a simple list can be stored and retrieved successfully.
        """
        SOME_VALUE = [u'abc', u'def, ghi', u'jkl']
        SOME_VALUE = ['abc', 'def, ghi', 'jkl']
        self.tryRoundtrip(SOME_VALUE)



@@ -332,10 +332,10 @@

Loading

332	332		"""
333	333
334	334		oldCases = [
335		-	(u'foo', [u'foo']),
336		-	(u'', [u'']),
337		-	(u'\x1f', [u'', u'']),
338		-	(u'foo\x1fbar', [u'foo', u'bar']),
	335	+	('foo', ['foo']),
	336	+	('', ['']),
	337	+	('\x1f', ['', '']),
	338	+	('foo\x1fbar', ['foo', 'bar']),
339	339		]
340	340
341	341		for dbval, pyval in oldCases:

@@ -370,7 +370,7 @@

Loading

        """
        Test that an L{SQLAttribute} knows its own local name.
        """
        self.assertEquals(
        self.assertEqual(
            SQLAttributeDummyClass.dummyAttribute.attrname,
            'dummyAttribute')


@@ -382,7 +382,7 @@

Loading

        fully qualified Python name of the type it is defined on (plus a dot)
        plus the name of the attribute.
        """
        self.assertEquals(
        self.assertEqual(
            SQLAttributeDummyClass.dummyAttribute.fullyQualifiedName(),
            'axiom.test.test_attributes.SQLAttributeDummyClass.dummyAttribute')


@@ -394,7 +394,7 @@

Loading

        is unfortunately implemented differently than other columns, due to its
        presence on Item.
        """
        self.assertEquals(
        self.assertEqual(
            SQLAttributeDummyClass.storeID.fullyQualifiedName(),
            'axiom.test.test_attributes.SQLAttributeDummyClass.storeID')


@@ -406,7 +406,7 @@

Loading

        recognizable as an invalid Python identifier.
        """
        ph = Placeholder(SQLAttributeDummyClass)
        self.assertEquals(
        self.assertEqual(
            'axiom.test.test_attributes.SQLAttributeDummyClass'
            '.dummyAttribute.<placeholder:%d>' % (ph._placeholderCount,),
            ph.dummyAttribute.fullyQualifiedName())

@@ -418,9 +418,9 @@

Loading

        its value when given an instance.
        """
        dummy = FullImplementationDummyClass(dummyAttribute=1234)
        self.assertEquals(
        self.assertEqual(
            FullImplementationDummyClass.dummyAttribute.__get__(dummy), 1234)
        self.assertEquals(dummy.dummyAttribute, 1234)
        self.assertEqual(dummy.dummyAttribute, 1234)


    def test_storeIDAccessor(self):

@@ -438,10 +438,10 @@

Loading

        its value when given an instance.
        """
        dummy = FullImplementationDummyClass(dummyAttribute=1234)
        self.assertEquals(
        self.assertEqual(
            Placeholder(FullImplementationDummyClass
                        ).dummyAttribute.__get__(dummy), 1234)
        self.assertEquals(dummy.dummyAttribute, 1234)
        self.assertEqual(dummy.dummyAttribute, 1234)


    def test_typeAttribute(self):

@@ -19,18 +19,18 @@

Loading

    def testTagging(self):
        s = Store()
        c = Catalog(store=s)
        g1 = Gizmo(store=s, name=u'one')
        g2 = Gizmo(store=s, name=u'two')
        g1 = Gizmo(store=s, name='one')
        g2 = Gizmo(store=s, name='two')

        c.tag(g1, u'single')
        c.tag(g1, u'multi')
        c.tag(g2, u'multi')
        c.tag(g1, u'multi')
        c.tag(g1, 'single')
        c.tag(g1, 'multi')
        c.tag(g2, 'multi')
        c.tag(g1, 'multi')

        self.assertEquals(list(c.tagsOf(g1)),
                          [u'single', u'multi'])
        self.assertEquals(list(c.tagsOf(g2)),
                          [u'multi'])
        self.assertEqual(list(c.tagsOf(g1)),
                          ['single', 'multi'])
        self.assertEqual(list(c.tagsOf(g2)),
                          ['multi'])

        self.assertEquals(list(c.objectsIn(u'single')), [g1])
        self.assertEquals(list(c.objectsIn(u'multi')), [g1, g2])
        self.assertEqual(list(c.objectsIn('single')), [g1])
        self.assertEqual(list(c.objectsIn('multi')), [g1, g2])

@@ -54,10 +54,11 @@

Loading

        """
        topdb = filepath.FilePath(self.mktemp())
        s = Store(topdb)
        inparent = SubStored(store=s, a=u'text value', b=b'bytes value')
        ss = SubStore.createNew(s, ['account', 'bob@divmod.com'])
        s2 = ss.open()

        ssd = SubStored(store=s2, a=u'hello world', b='what, its text')
        ssd = SubStored(store=s2, a=u'hello world', b=b'what, its text')
        oid = ss.storeID
        oid2 = ssd.storeID


@@ -65,12 +66,17 @@

Loading

        s.close()

        reopens = Store(topdb)
        reinparent = reopens.getItemByID(inparent.storeID)

        self.assertEqual(reinparent.a, u'text value')
        self.assertEqual(reinparent.b, b'bytes value')

        reopenss = reopens.getItemByID(oid)
        reopens2 = reopenss.open()
        reopenssd = reopens2.getItemByID(oid2)

        self.assertEquals(reopenssd.a, u'hello world')
        self.assertEquals(reopenssd.b, 'what, its text')
        self.assertEqual(reopenssd.a, u'hello world')
        self.assertEqual(reopenssd.b, b'what, its text')


    def test_oneThingMemory(self):

@@ -81,7 +87,7 @@

Loading

        ss = SubStore.createNew(s, ['account', 'bob@divmod.com'])
        s2 = ss.open()

        ssd = SubStored(store=s2, a=u'hello world', b='what, its text')
        ssd = SubStored(store=s2, a=u'hello world', b=b'what, its text')
        oid = ss.storeID
        oid2 = ssd.storeID


@@ -89,8 +95,8 @@

Loading

        self.assertIdentical(s.getItemByID(oid), ss)
        self.assertIdentical(ss.open(), s2)
        item = s2.getItemByID(oid2)
        self.assertEquals(item.a, u'hello world')
        self.assertEquals(item.b, 'what, its text')
        self.assertEqual(item.a, u'hello world')
        self.assertEqual(item.b, b'what, its text')


    def test_hereTodayGoneTomorrow(self):

@@ -101,7 +107,7 @@

Loading

        ss = SubStore.createNew(s, ['account', 'bob@divmod.com'])
        s2 = ss.open()

        ssd = SubStored(store=s2, a=u'hello world', b='what, its text')
        ssd = SubStored(store=s2, a=u'hello world', b=b'what, its text')
        oid = ss.storeID
        oid2 = ssd.storeID
        s2.close()

@@ -111,8 +117,8 @@

Loading

        ss = s.getItemByID(oid)
        s2 = ss.open()
        item = s2.getItemByID(oid2)
        self.assertEquals(item.a, u'hello world')
        self.assertEquals(item.b, 'what, its text')
        self.assertEqual(item.a, u'hello world')
        self.assertEqual(item.b, b'what, its text')


    def test_memorySubstoreFile(self):

@@ -125,7 +131,7 @@

Loading

        ss = SubStore.createNew(s, ['account', 'bob@divmod.com'])
        s2 = ss.open()
        f = s2.newFile("test.txt")
        f.write("yay")
        f.write(b"yay")
        f.close()
        self.assertEqual(open(f.finalpath.path).read(), "yay")


@@ -147,11 +153,11 @@

Loading

        Substores use the debug and journal configuration of the parent store.
        """
        filesdir = filepath.FilePath(self.mktemp())
        s = Store(filesdir=filesdir, debug=True, journalMode=u'MEMORY')
        s = Store(filesdir=filesdir, debug=True, journalMode='MEMORY')
        ss = SubStore.createNew(s, ['account', 'bob@divmod.com'])
        s2 = ss.open()
        self.assertEqual(s2.debug, True)
        self.assertEqual(s2.journalMode, u'MEMORY')
        self.assertEqual(s2.journalMode, 'MEMORY')




@@ -182,7 +188,7 @@

Loading

        ycst = YouCantStartThis(store=ss)
        ss.powerUp(ycst, IService)
        self._startService()
        self.failIf(ycst.started)
        self.assertFalse(ycst.started)

    def testStartEverythingExplicitly(self):
        """

@@ -194,7 +200,7 @@

Loading

        ss.powerUp(ysst, IService)
        self.topdb.powerUp(self.ssitem, IService)
        self._startService()
        self.failUnless(ysst.started)
        self.assertTrue(ysst.started)

    def _startService(self):
        """

@@ -116,11 +116,11 @@

Loading

        axiomConnection = self.createAxiomConnection(stubConnection)
        axiomCursor = axiomConnection.cursor()

        self.assertEquals(len(stubConnection.cursors), 1)
        self.assertEqual(len(stubConnection.cursors), 1)
        statement = "SELECT foo FROM bar"
        axiomCursor.execute(statement)
        self.assertEquals(len(stubConnection.cursors[0].statements), 1)
        self.assertEquals(stubConnection.cursors[0].statements[0], statement)
        self.assertEqual(len(stubConnection.cursors[0].statements), 1)
        self.assertEqual(stubConnection.cursors[0].statements[0], statement)


    def test_timeoutExceeded(self):

@@ -152,13 +152,13 @@

Loading

            TimeoutError,
            axiomCursor.execute, statement)

        self.failUnless(
        self.assertTrue(
            self.TIMEOUT <= time() <= self.TIMEOUT + self.ALLOWED_SLOP,
            "Wallclock duration of execute() call out of bounds.")

        self.assertEquals(timeoutException.statement, statement)
        self.assertEquals(timeoutException.timeout, self.TIMEOUT)
        self.failUnless(isinstance(
        self.assertEqual(timeoutException.statement, statement)
        self.assertEqual(timeoutException.timeout, self.TIMEOUT)
        self.assertTrue(isinstance(
                timeoutException.underlying,
                self.expectedUnderlyingExceptionClass))


@@ -3,6 +3,7 @@

Loading

__metaclass__ = type

import gc
import six
from zope.interface import implementer, Interface

from inspect import getabsfile

@@ -24,6 +25,7 @@

Loading

    reference, text, integer, AND, _cascadingDeletes, _disallows)
import six
from six.moves import zip
from functools import total_ordering

_typeNameToMostRecentClass = WeakValueDictionary()


@@ -98,11 +100,36 @@

Loading

        in SQL generation, which is beneficial for debugging and performance
        purposes.
        """
        if isinstance(other, MetaItem):
        # cmp is only available on Python 2
        if six.PY2 and isinstance(other, MetaItem):
            return cmp((self.typeName, self.schemaVersion),
                       (other.typeName, other.schemaVersion))
        return NotImplemented

    def _makeComparator(opfunc):
        """
        since @total_ordering doesn't work on metaclasses, let's do our own
        """
        def __op__(self, other):
            if not isinstance(other, MetaItem): # pragma: no cover
                return NotImplemented
            return opfunc((self.typeName, self.schemaVersion), (other.typeName, other.schemaVersion))
        return __op__

    import operator
    __lt__ = _makeComparator(operator.lt)
    __le__ = _makeComparator(operator.le)
    __gt__ = _makeComparator(operator.gt)
    __ge__ = _makeComparator(operator.ge)
    __eq__ = _makeComparator(operator.eq)

    def __hash__(self):
        """
        Since we've defined an ordering, we have to implement hashability for py3 as well.
        """
        return hash((self.typeName, self.schemaVersion)) + 7



def noop():
    pass

@@ -268,7 +295,7 @@

Loading

        else:
            forc = self.store.findOrCreate(_PowerupConnector,
                                           item=self,
                                           interface=unicode(qual(interface)),
                                           interface=str(qual(interface)),
                                           powerup=powerup)
            forc.priority = priority


@@ -298,7 +325,7 @@

Loading

        else:
            for cable in self.store.query(_PowerupConnector,
                                          AND(_PowerupConnector.item == self,
                                              _PowerupConnector.interface == unicode(qual(interface)),
                                              _PowerupConnector.interface == str(qual(interface)),
                                              _PowerupConnector.powerup == powerup)):
                cable.deleteFromStore()
                return

@@ -344,7 +371,7 @@

Loading

            yield inMemoryPowerup
        if self.store is None:
            return
        name = unicode(qual(interface), 'ascii')
        name = qual(interface)
        for cable in self.store.query(
            _PowerupConnector,
            AND(_PowerupConnector.interface == name,

@@ -570,7 +597,7 @@

Loading

        """
        attrs = ", ".join("{n}={v}".format(n=name, v=attr.reprFor(self))
                          for name, attr in sorted(self.getSchema()))
        template = b"{s.__name__}({attrs}, storeID={s.storeID})@{id:#x}"
        template = "{s.__name__}({attrs}, storeID={s.storeID})@{id:#x}"
        return template.format(s=self, attrs=attrs, id=id(self))



@@ -955,7 +982,6 @@

Loading

    getTableAlias = classmethod(getTableAlias)



@implementer(IColumn)
class _PlaceholderColumn(_ContainableMixin, _ComparisonOperatorMuxer,
                         _MatchingOperationMuxer, _OrderingMixin):

@@ -1007,6 +1033,7 @@

Loading


_placeholderCount = 0

@total_ordering
class Placeholder(object):
    """
    Wrap an existing L{Item} type to provide a different name for it.

@@ -1046,6 +1073,24 @@

Loading

        self.existingInStore = self._placeholderItemClass.existingInStore


    def __lt__(self, other):
        """
        Provide a deterministic sort order between Placeholder instances.
        """
        if isinstance(other, Placeholder):
            return self._placeholderCount < other._placeholderCount
        return NotImplemented


    def __eq__(self, other):
        """
        Provide a deterministic sort order between Placeholder instances.
        """
        if isinstance(other, Placeholder):
            return self._placeholderCount == other._placeholderCount
        return NotImplemented


    def __cmp__(self, other):
        """
        Provide a deterministic sort order between Placeholder instances.

@@ -155,12 +155,12 @@

Loading

            length += 1
        self.length = length

    def sort(self, *args):
    def sort(self, *args, **kwargs):
        # We want to sort by value, not sort by _ListItem.  We could
        # accomplish this by having _ListItem.__cmp__ do something
        # with self._value, but that seemed wrong. This was easier.
        values = [li._value for li in self._queryListItems()]
        values.sort(*args)
        values.sort(*args, **kwargs)
        index = 0
        for li in self._queryListItems():
            # XXX: Well, can it?

@@ -32,6 +32,7 @@

Loading


import warnings
from threading import Thread
import six

from zope.interface import implementer, Interface


@@ -56,7 +57,7 @@

Loading

from axiom.scheduler import IScheduler
from axiom import upgrade, iaxiom

ANY_PROTOCOL = u'*'
ANY_PROTOCOL = '*'

def dflip(x):
    warnings.warn("Don't use dflip no more", stacklevel=2)

@@ -336,7 +337,9 @@

Loading

        realm = self.store.findUnique(LoginSystem)

        def _hashed(hash):
            self.passwordHash = hash.decode('ascii')
            # apparently txpasslib gives us bytes hashes on py2, text hashes on
            # py3; let's make those consistent.
            self.passwordHash = hash.decode('ascii') if isinstance(hash, bytes) else hash

        return realm._getCC().hash(newPassword).addCallback(_hashed)


@@ -464,7 +467,7 @@

Loading

    password = oldAccount.password
    if password is not None:
        try:
            password = password.decode('ascii')
            password = six.ensure_str(password)
        except UnicodeDecodeError:
            password = None


@@ -480,7 +483,7 @@

Loading

            localpart=oldAccount.username,
            domain=oldAccount.domain,
            internal=False,
            protocol=u'email',
            protocol='email',
            account=acc,
            verified=True)


@@ -510,7 +513,7 @@

Loading

    if oldAccount.password is None:
        passwordHash = None
    else:
        passwordHash = _globalCC.hash(oldAccount.password).decode('ascii')
        passwordHash = six.ensure_str(_globalCC.hash(oldAccount.password))
    return oldAccount.upgradeVersion(
        'login', 2, 3,
        passwordHash=passwordHash,

@@ -558,7 +561,7 @@

Loading



    def addAccount(self, username, domain, password, avatars=None,
                   protocol=u'email', disabled=0, internal=False,
                   protocol='email', disabled=0, internal=False,
                   verified=True):
        """
        Create a user account, add it to this LoginBase, and return it.

@@ -590,14 +593,14 @@

Loading


        # unicode(None) == u'None', kids.
        if username is not None:
            username = unicode(username)
            username = six.ensure_text(username)
        if domain is not None:
            domain = unicode(domain)
            domain = six.ensure_text(domain)
        if password is None:
            passwordHash = None
        else:
            password = unicode(password)
            passwordHash = _globalCC.hash(password).decode('ascii')
            password = six.ensure_text(password)
            passwordHash = six.ensure_str(_globalCC.hash(password))

        if self.accountByAddress(username, domain) is not None:
            raise DuplicateUser(username, domain)

@@ -663,8 +666,8 @@

Loading

            self.failedLogins += 1
            raise MissingDomainPart(credentials.username)

        username = unicode(username)
        domain = unicode(domain)
        username = six.ensure_text(username)
        domain = six.ensure_text(domain)

        acct = self.accountByAddress(username, domain)
        if acct is not None:

@@ -697,7 +700,7 @@

Loading

    them by protocol
    """
    if protocol is not None:
        comp = OR(LoginMethod.protocol == u'*',
        comp = OR(LoginMethod.protocol == '*',
                  LoginMethod.protocol == protocol)
    else:
        comp = None

@@ -16,7 +16,8 @@

Loading

        p = Portal(IRealm(self.store),
                   [ICredentialsChecker(self.store)])

        def loggedIn((ifc, av, lgo)):
        def loggedIn(args):
            (ifc, av, lgo) = args
            assert av.garbage == 7
            return av.store.whenFullyUpgraded()
        d = p.login(

@@ -6,7 +6,11 @@

Loading

from axiom.sequence import List
from axiom.store import Store

from functools import total_ordering
from operator import lt, eq


@total_ordering
class SomeItem(Item):
    schemaVersion = 1
    typeName = 'test_sequence_some_item'

@@ -20,6 +24,16 @@

Loading

            return cmp(super(SomeItem, self), other)
        return cmp(self.foo, other.foo)

    def __lt__(self, other):
        if not isinstance(other, self.__class__):
            return lt(super(SomeItem, self), other)
        return lt(self.foo, other.foo)

    def __eq__(self, other):
        if not isinstance(other, self.__class__):
            return eq(super(SomeItem, self), other)
        return eq(self.foo, other.foo)

class SequenceTestCase(unittest.TestCase):
    def setUp(self):
        self.store = Store()

@@ -29,14 +43,14 @@

Loading

            setattr(self, 'i%i'%i, item)

    def assertContents(self, seq, L):
        self.assertEquals(len(seq), len(L))
        self.assertEqual(len(seq), len(L))
        for i in range(len(L)):
            self.assertIdentical(seq[i], L[i])

class TestSequenceOfItems(SequenceTestCase):
    def test_createItem(self):
        seq = List(store=self.store)
        self.assertEquals(len(seq), 0)
        self.assertEqual(len(seq), 0)

    def test_createItemWithDefaults(self):
        seq = List([self.i0, self.i1], store=self.store)

@@ -55,12 +69,12 @@

Loading

    def test_appendAndGetItem(self):
        seq = List(store=self.store)
        seq.append(self.i0)
        self.assertEquals(len(seq), 1)
        self.assertEquals(seq[0], self.i0)
        self.assertEqual(len(seq), 1)
        self.assertEqual(seq[0], self.i0)
        seq.append(self.i1)
        seq.append(self.i2)
        self.assertEquals(seq[1], self.i1)
        self.assertEquals(seq[2], self.i2)
        self.assertEqual(seq[1], self.i1)
        self.assertEqual(seq[2], self.i2)

    def test_appendSliceSyntax(self):
        seq = List(store=self.store)

@@ -77,7 +91,7 @@

Loading

        seq = List(store=self.store)
        self.assertRaises(IndexError, seq.__getitem__, 0)
        seq.append(self.i0)
        self.assertEquals(seq[0], self.i0)
        self.assertEqual(seq[0], self.i0)
        self.assertRaises(IndexError, seq.__getitem__, 1)

    def test_negativeIndices(self):

@@ -85,34 +99,34 @@

Loading

        seq.append(self.i0)
        seq.append(self.i1)
        seq.append(self.i2)
        self.assertEquals(seq[-1], self.i2)
        self.assertEquals(seq[-2], self.i1)
        self.assertEquals(seq[-3], self.i0)
        self.assertEqual(seq[-1], self.i2)
        self.assertEqual(seq[-2], self.i1)
        self.assertEqual(seq[-3], self.i0)
        self.assertRaises(IndexError, seq.__getitem__, -4)

    def test_setItem(self):
        seq = List(store=self.store)
        seq.append(self.i0)
        seq.append(self.i1)
        self.assertEquals(len(seq), 2)
        self.assertEquals(seq[0], self.i0)
        self.assertEquals(seq[1], self.i1)
        self.assertEqual(len(seq), 2)
        self.assertEqual(seq[0], self.i0)
        self.assertEqual(seq[1], self.i1)
        seq[1] = self.i2
        self.assertEquals(seq[1], self.i2)
        self.assertEqual(seq[1], self.i2)

    def test_delItem(self):
        seq = List(store=self.store)
        seq.append(self.i1)
        seq.append(self.i2)
        seq.append(self.i3)
        self.assertEquals(seq.length, 3)
        self.assertEquals(seq[0], self.i1)
        self.assertEquals(seq[1], self.i2)
        self.assertEquals(seq[2], self.i3)
        self.assertEqual(seq.length, 3)
        self.assertEqual(seq[0], self.i1)
        self.assertEqual(seq[1], self.i2)
        self.assertEqual(seq[2], self.i3)
        del seq[1]
        self.assertEquals(seq.length, 2)
        self.assertEquals(seq[0], self.i1)
        self.assertEquals(seq[1], self.i3)
        self.assertEqual(seq.length, 2)
        self.assertEqual(seq[0], self.i1)
        self.assertEqual(seq[1], self.i3)
        self.assertRaises(IndexError, seq.__getitem__, 2)



@@ -125,14 +139,14 @@

Loading

    def test_x_in_s(self):
        seq = List(store=self.store)
        seq.append(self.i0)
        self.failUnless(self.i0 in seq)
        self.failIf(self.xy in seq)
        self.assertTrue(self.i0 in seq)
        self.assertFalse(self.xy in seq)

    def test_x_not_in_s(self):
        seq = List(store=self.store)
        seq.append(self.i0)
        self.failUnless(self.xy not in seq)
        self.failIf(self.i0 not in seq)
        self.assertTrue(self.xy not in seq)
        self.assertFalse(self.i0 not in seq)

    def test_s_plus_t(self):
        L1 = List(store=self.store)

@@ -142,13 +156,13 @@

Loading

        # XXX ASSUMPTION: all operations which return another
        # instance will return regular lists, *not* Lists.
        L = L1 + L2
        self.assertEquals(L, [self.i0, self.i1])
        self.assertEqual(L, [self.i0, self.i1])

    def test_shallow_copies(self, n=3):
        seq = List(store=self.store)
        seq.append(self.i0)
        for L in (seq * n, n * seq):
            self.assertEquals(L, [self.i0]*n)
            self.assertEqual(L, [self.i0]*n)

    def test_index(self):
        seq = List(store=self.store)

@@ -165,10 +179,10 @@

Loading

        seq.append(self.i1)
        seq.append(self.i2)
        seq.append(self.i3)
        self.assertEquals(seq[0:2], [self.i0, self.i1])
        self.assertEquals(seq[0:3], [self.i0, self.i1, self.i2])
        self.assertEquals(seq[1:0], [])
        self.assertEquals(seq[-1:], [self.i3])
        self.assertEqual(seq[0:2], [self.i0, self.i1])
        self.assertEqual(seq[0:3], [self.i0, self.i1, self.i2])
        self.assertEqual(seq[1:0], [])
        self.assertEqual(seq[-1:], [self.i3])
    test_slices.todo = "Slices are not supported yet"

    def test_slice_with_step(self):

@@ -177,19 +191,19 @@

Loading

        seq.append(self.i1)
        seq.append(self.i2)
        seq.append(self.i3)
        self.assertEquals(seq[0:4:2], [self.i0, self.i2])
        self.assertEquals(seq[1:5:2], [self.i1, self.i3])
        self.assertEqual(seq[0:4:2], [self.i0, self.i2])
        self.assertEqual(seq[1:5:2], [self.i1, self.i3])
    test_slice_with_step.todo = "Slices are not supported yet"

    def test_len(self):
        seq = List(store=self.store)
        self.assertEquals(len(seq), 0)
        self.assertEqual(len(seq), 0)
        seq.append(self.i0)
        self.assertEquals(len(seq), 1)
        self.assertEqual(len(seq), 1)
        seq.append(self.i0)
        self.assertEquals(len(seq), 2)
        self.assertEqual(len(seq), 2)
        seq.append(self.i0)
        self.assertEquals(len(seq), 3)
        self.assertEqual(len(seq), 3)

    def test_min_max(self):
        seq = List(store=self.store)

@@ -245,7 +259,7 @@

Loading

        seq.append(self.i2)
        seq.append(self.i3)
        del seq[1:3]
        self.assertEquals(len(seq), 2)
        self.assertEqual(len(seq), 2)
        self.assertIdentical(seq[0], self.i0)
        self.assertIdentical(seq[1], self.i3)
    test_deleteSlice.todo = "Slices are not supported yet"

@@ -329,10 +343,10 @@

Loading

        seq.append(self.i2)
        seq.append(self.i0)
        seq.append(self.i2)
        self.assertEquals(seq.count(self.i0), 3)
        self.assertEquals(seq.count(self.i1), 1)
        self.assertEquals(seq.count(self.i2), 2)
        self.assertEquals(seq.count(self.i3), 0)
        self.assertEqual(seq.count(self.i0), 3)
        self.assertEqual(seq.count(self.i1), 1)
        self.assertEqual(seq.count(self.i2), 2)
        self.assertEqual(seq.count(self.i3), 0)

    def test_index(self):
        seq = List(store=self.store)

@@ -342,13 +356,13 @@

Loading

        seq.append(self.i2)
        seq.append(self.i0)
        seq.append(self.i2)
        self.assertEquals(seq.index(self.i0),    0)
        self.assertEquals(seq.index(self.i0, 0), 0)
        self.assertEquals(seq.index(self.i0, 1), 2)
        self.assertEquals(seq.index(self.i1),    1)
        self.assertEquals(seq.index(self.i1, 1), 1)
        self.assertEquals(seq.index(self.i2),    3)
        self.assertEquals(seq.index(self.i2, 4), 5)
        self.assertEqual(seq.index(self.i0),    0)
        self.assertEqual(seq.index(self.i0, 0), 0)
        self.assertEqual(seq.index(self.i0, 1), 2)
        self.assertEqual(seq.index(self.i1),    1)
        self.assertEqual(seq.index(self.i1, 1), 1)
        self.assertEqual(seq.index(self.i2),    3)
        self.assertEqual(seq.index(self.i2, 4), 5)
        self.assertRaises(ValueError, seq.index, self.i3)
        self.assertRaises(ValueError, seq.index, self.i1, 3)
        self.assertRaises(ValueError, seq.index, self.i0, 1, 1)

@@ -501,42 +515,21 @@

Loading

                                  self.i4])

        seq_randomize()
        seq.sort(lambda x,y: cmp(y,x))
        seq.sort(key=lambda each: -each.foo)
        self.assertContents(seq, [self.i4,
                                  self.i3,
                                  self.i2,
                                  self.i1,
                                  self.i0])

        def strangecmp(x, y):
            xfoo, yfoo = x.foo, y.foo
            if xfoo < 3:
                xfoo += 100
            if yfoo < 3:
                yfoo += 100
            return cmp(xfoo, yfoo)
        seq_randomize()
        seq.sort(strangecmp)
        self.assertContents(seq, [self.i3,
                                  self.i4,
                                  self.i0,
                                  self.i1,
                                  self.i2])

        seq_randomize()
        seq.sort(None, lambda x:x, True)
        seq.sort(reverse=True)
        self.assertContents(seq, [self.i4,
                                  self.i3,
                                  self.i2,
                                  self.i1,
                                  self.i0])
        seq_randomize()
        seq.sort(strangecmp, lambda x:x, True)
        self.assertContents(seq, [self.i2,
                                  self.i1,
                                  self.i0,
                                  self.i4,
                                  self.i3])

    def test_count(self):
        seq = List(store=self.store)

@@ -546,27 +539,27 @@

Loading

        seq.append(self.i3)
        seq.append(self.i3)
        seq.append(self.i3)
        self.assertEquals(seq.count(self.i1), 1)
        self.assertEquals(seq.count(self.i2), 2)
        self.assertEquals(seq.count(self.i3), 3)
        self.assertEqual(seq.count(self.i1), 1)
        self.assertEqual(seq.count(self.i2), 2)
        self.assertEqual(seq.count(self.i3), 3)

    def test_contains(self):
        seq = List(store=self.store)
        seq.append(self.i1)
        seq.append(self.i2)
        self.failUnless(self.i1 in seq)
        self.failUnless(self.i2 in seq)
        self.failIf(self.i3 in seq)
        self.assertTrue(self.i1 in seq)
        self.assertTrue(self.i2 in seq)
        self.assertFalse(self.i3 in seq)

    def test_multicontains(self):
        seq1 = List(store=self.store)
        seq2 = List(store=self.store)
        seq1.append(self.i1)
        seq2.append(self.i2)
        self.failUnless(self.i1 in seq1)
        self.failUnless(self.i2 in seq2)
        self.failIf(self.i1 in seq2)
        self.failIf(self.i2 in seq1)
        self.assertTrue(self.i1 in seq1)
        self.assertTrue(self.i2 in seq2)
        self.assertFalse(self.i1 in seq2)
        self.assertFalse(self.i2 in seq1)

    def test_multidelitem(self):
        seq1 = List(store=self.store)

@@ -7,9 +7,8 @@

Loading

from __future__ import print_function

import six
from six.moves import map

import time, os, itertools, warnings, sys, operator, weakref
import time, os, itertools, warnings, sys, operator, weakref, six, io

from zope.interface import implementer


@@ -62,7 +61,7 @@

Loading



@implementer(iaxiom.IAtomicFile)
class AtomicFile(file):
class AtomicFile(io.FileIO, object):
    """I am a file which is moved from temporary to permanent storage when it
    is closed.


@@ -79,7 +78,7 @@

Loading

        called.
        """
        self._destpath = destpath
        file.__init__(self, tempname, 'w+b')
        super(AtomicFile, self).__init__(tempname, 'w+')

    def close(self):
        """

@@ -90,12 +89,12 @@

Loading

        """
        now = time.time()
        try:
            file.close(self)
            super(AtomicFile, self).close()
            _mkdirIfNotExists(self._destpath.dirname())
            self.finalpath = self._destpath
            os.rename(self.name, self.finalpath.path)
            os.utime(self.finalpath.path, (now, now))
        except:
        except Exception:
            return defer.fail()
        return defer.succeed(self.finalpath)


@@ -167,7 +166,6 @@

Loading

            and ((typename, version) not in _legacyTypes))



@implementer(iaxiom.IQuery)
class BaseQuery:
    """

@@ -181,7 +179,7 @@

Loading

    # XXX: need a better convention for this sort of
    # abstract-but-provide-most-of-a-base-implementation thing. -glyph

    # How about not putting the implements(iaxiom.IQuery) here, but on
    # How about not putting the @implementer(iaxiom.IQuery) here, but on
    # subclasses instead? -exarkun

    def __init__(self, store, tableClass,

@@ -634,10 +632,13 @@

Loading

        # If there's a 'deleted' callback on the Item type or 'deleteFromStore'
        # is overridden, we have to do it the slow way.
        deletedOverridden = (
            self.tableClass.deleted.im_func is not item.Item.deleted.im_func)
            six.get_unbound_function(self.tableClass.deleted) is not
            six.get_unbound_function(item.Item.deleted)
        )
        deleteFromStoreOverridden = (
            self.tableClass.deleteFromStore.im_func is not
            item.Item.deleteFromStore.im_func)
            six.get_unbound_function(self.tableClass.deleteFromStore) is not
            six.get_unbound_function(item.Item.deleteFromStore)
        )

        if deletedOverridden or deleteFromStoreOverridden:
            for it in self:

@@ -1021,14 +1022,13 @@

Loading

    diff = []
    if diskOnly:
        diff.append('Only on disk:')
        diff.extend(map(repr, diskOnly))
        diff.extend(list(map(repr, diskOnly)))
    if memoryOnly:
        diff.append('Only in memory:')
        diff.extend(map(repr, memoryOnly))
        diff.extend(list(map(repr, memoryOnly)))
    return '\n'.join(diff)



@implementer(iaxiom.IBeneficiary)
class Store(Empowered):
    """

@@ -1167,7 +1167,9 @@

Loading

        self.typeToDeleteSQLCache = {}

        self.typeToTableNameCache = {}
        self.attrToColumnNameCache = {}
        self.attrNameToColumnNameCache = {}  # map fully-qualified attribute
                                             # names (native str?) to database
                                             # column names

        self._upgradeManager = upgrade._StoreUpgrade(self)


@@ -1752,13 +1754,13 @@

Loading

        indices = {}
        schema = [attr for (name, attr) in itemType.getSchema()]
        for i, attr in enumerate(itemAttributes):
            indices[attr] = i
            indices[attr.attrname] = i
        for row in dataRows:
            oid = self.store.executeSchemaSQL(
                _schema.CREATE_OBJECT, [self.store.getTypeID(itemType)])
            insertArgs = [oid]
            for attr in schema:
                i = indices.get(attr, _NEEDS_DEFAULT)
                i = indices.get(attr.attrname, _NEEDS_DEFAULT)
                if i is _NEEDS_DEFAULT:
                    pyval = attr.default
                else:

@@ -1921,11 +1923,13 @@

Loading

                          self.typeToTableNameCache) :
                if tableClass in cache:
                    del cache[tableClass]
            if tableClass.storeID in self.attrToColumnNameCache:
                del self.attrToColumnNameCache[tableClass.storeID]
            qualifiedStoreIDName = tableClass.storeID.fullyQualifiedName()
            if qualifiedStoreIDName in self.attrNameToColumnNameCache:
                del self.attrNameToColumnNameCache[qualifiedStoreIDName]
            for name, attr in tableClass.getSchema():
                if attr in self.attrToColumnNameCache:
                    del self.attrToColumnNameCache[attr]
                attrFQN = attr.fullyQualifiedName()
                if attrFQN in self.attrNameToColumnNameCache:
                    del self.attrNameToColumnNameCache[attrFQN]

        for sub in self._attachedChildren.values():
            sub._inMemoryRollback()

@@ -1937,7 +1941,7 @@

Loading

        self.touched = None
        self.executedThisTransaction = None
        self.tablesCreatedThisTransaction = []
        for sub in self._attachedChildren.values():
        for sub in list(self._attachedChildren.values()):
            sub._cleanupTxnState()

    def close(self, _report=True):

@@ -2045,11 +2049,12 @@

Loading


        @return: a string
        """
        if attribute not in self.attrToColumnNameCache:
            self.attrToColumnNameCache[attribute] = '.'.join(
        name = attribute.fullyQualifiedName()
        if name not in self.attrNameToColumnNameCache:
            self.attrNameToColumnNameCache[name] = '.'.join(
                (self.getTableName(attribute.type),
                 self.getShortColumnName(attribute)))
        return self.attrToColumnNameCache[attribute]
        return self.attrNameToColumnNameCache[name]


    def getTypeID(self, tableClass):

@@ -3,6 +3,7 @@

Loading

from __future__ import print_function
import sys
import os
import six

from twisted.trial import unittest
from twisted.internet import protocol, defer

@@ -119,7 +120,7 @@

Loading

        x = len(s.typeToTableNameCache)
        for i in range(10):
            s.getTableName(TestItem)
        self.assertEquals(x, len(s.typeToTableNameCache))
        self.assertEqual(x, len(s.typeToTableNameCache))


    def testStoreIDComparerIdentity(self):

@@ -174,7 +175,7 @@

Loading

            TestItem,
            {(TestItem.typeName, TestItem.schemaVersion): schema[:-1]})
        self.assertEqual(
            e1[0],
            e1.args[0],
            "Schema mismatch on already-loaded "
            "<class 'axiom.test.test_xatop.TestItem'> <'TestItem'> object "
            "version 1:\n"

@@ -189,7 +190,7 @@

Loading

            {(TestItem.typeName, TestItem.schemaVersion):
             schema + [('extra', 'INTEGER')]})
        self.assertEqual(
            e2[0],
            e2.args[0],
            "Schema mismatch on already-loaded "
            "<class 'axiom.test.test_xatop.TestItem'> <'TestItem'> object "
            "version 1:\n"

@@ -204,7 +205,7 @@

Loading

            {(TestItem.typeName, TestItem.schemaVersion):
             [(schema[0][0], 'VARCHAR(64) (this is made up)')] + schema[1:]})
        self.assertEqual(
            e3[0],
            e3.args[0],
            "Schema mismatch on already-loaded "
            "<class 'axiom.test.test_xatop.TestItem'> <'TestItem'> object "
            "version 1:\n"

@@ -358,7 +359,7 @@

Loading


            # Write out the source.
            modulePath = importPath.child(moduleName + ".py")
            modulePath.setContent("""\
            modulePath.setContent(b"""\
from axiom.item import Item
from axiom.attributes import integer


@@ -370,7 +371,7 @@

Loading

        # loaded in this process, create a store containing instances of the
        # Unloaded types.
        script = filepath.FilePath(self.mktemp())
        script.setContent("""\
        script.setContent(b"""\
from sys import argv
from twisted.python.reflect import namedAny
from axiom.store import Store

@@ -427,10 +428,10 @@

Loading

        Passing a journalling mode sets that mode on open.
        """
        dbdir = filepath.FilePath(self.mktemp())
        s = store.Store(dbdir, journalMode=u'MEMORY')
        self.assertEquals(
        s = store.Store(dbdir, journalMode='MEMORY')
        self.assertEqual(
            s.querySchemaSQL('PRAGMA *DATABASE*.journal_mode'),
            [(u'memory',)])
            [('memory',)])


    def test_journalModeNone(self):

@@ -438,12 +439,12 @@

Loading

        Passing a journalling mode of C{None} sets no mode.
        """
        dbdir = filepath.FilePath(self.mktemp())
        s = store.Store(dbdir, journalMode=u'WAL')
        s = store.Store(dbdir, journalMode='WAL')
        s.close()
        s = store.Store(dbdir, journalMode=None)
        self.assertEquals(
        self.assertEqual(
            s.querySchemaSQL('PRAGMA *DATABASE*.journal_mode'),
            [(u'wal',)])
            [('wal',)])




@@ -472,7 +473,7 @@

Loading


        t3.store = s1

        self.assertEquals(list(s1.query(TestItem)),
        self.assertEqual(list(s1.query(TestItem)),
                          [t1, t3])



@@ -490,14 +491,14 @@

Loading

                      checkactive=True,
                      other=tio)

        self.assertEquals(ti.checked, True)
        self.assertEqual(ti.checked, True)

    def testItemCreation(self):
        timeval = extime.Time.fromISO8601TimeAndDate('2004-10-05T10:12:14.1234')

        s = TestItem(
            foo = 42,
            bar = u'hello world',
            bar = 'hello world',
            baz = timeval,
            booleanT = True,
            booleanF = False

@@ -509,16 +510,16 @@

Loading

        self.store.close()
        self.store = store.Store(self.dbdir)
        s2 = self.store.getItemByID(sid)
        self.assertEquals(s2.foo, s.foo)
        self.assertEquals(s2.booleanT, s.booleanT)
        self.assertEquals(s2.booleanF, s.booleanF)
        self.assertEqual(s2.foo, s.foo)
        self.assertEqual(s2.booleanT, s.booleanT)

238	241		def __getPowerupInterfaces__(self, powerups):
239	242		yield (IAppliance, 0)
240	243
	244	+
	245	+	@dependency.dependable
241	246		class IceCrusher(Item):
242	247		blender = dependency.dependsOn(Blender)
243	248

313	318		dependency.installOn(e, foo)
314	319
315	320		ps = self.store.findUnique(PowerStrip)
316		-	self.failUnlessRaises(dependency.DependencyError,
	321	+	self.assertRaises(dependency.DependencyError,
317	322		dependency.uninstallFrom, ps, foo)
318	323
319	324		def test_properOrphaning(self):

223	223		"""
224	224		store = Store()
225	225		t = nonUpgradedItem(store=store)
226		-	self.assertEquals(t.__legacy__, True)
	226	+	self.assertEqual(t.__legacy__, True)
227	227		self.assertRaises(KeyError, store.objectCache.get, t.storeID)
228	228		t2 = store.getItemByID(t.storeID)
229	229		self.assertNotIdentical(t, t2)

249	249		s.query(ThingWithCharacterAndByteStrings,
250	250		ThingWithCharacterAndByteStrings.characterString == text1.lower(),
251	251		))
252		-	self.failIf(q, q)
	252	+	self.assertFalse(q, q)
253	253
254	254		q = list(
255	255		s.query(ThingWithCharacterAndByteStrings,
256	256		ThingWithCharacterAndByteStrings.characterString == text1.upper(),
257	257		))
258		-	self.failIf(q, q)
	258	+	self.assertFalse(q, q)
259	259
260	260		q = list(
261	261		s.query(ThingWithCharacterAndByteStrings,
262	262		ThingWithCharacterAndByteStrings.characterString == text1,
263	263		))
264	264
265		-	self.assertEquals(q, [x])
	265	+	self.assertEqual(q, [x])
266	266
267	267		q = list(
268	268		s.query(ThingWithCharacterAndByteStrings,
269	269		ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2,
270	270		))
271	271
272		-	self.assertEquals(q, [x])
	272	+	self.assertEqual(q, [x])
273	273
274	274		q = list(
275	275		s.query(ThingWithCharacterAndByteStrings,
276	276		ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2.lower(),
277	277		))
278	278
279		-	self.assertEquals(q, [x])
	279	+	self.assertEqual(q, [x])
280	280
281	281		q = list(
282	282		s.query(ThingWithCharacterAndByteStrings,
283	283		ThingWithCharacterAndByteStrings.caseInsensitiveCharString == text2.upper(),
284	284		))
285	285
286		-	self.assertEquals(q, [x])
	286	+	self.assertEqual(q, [x])
287	287
288	288		q = list(
289	289		s.query(ThingWithCharacterAndByteStrings,
290	290		ThingWithCharacterAndByteStrings.byteString == bytes1,
291	291		))
292	292
293		-	self.assertEquals(q, [x])
	293	+	self.assertEqual(q, [x])
294	294
295	295		q = list(
296	296		s.query(ThingWithCharacterAndByteStrings,
297	297		ThingWithCharacterAndByteStrings.byteString == bytes1.upper(),
298	298		))
299	299
300		-	self.failIf(q, q)
	300	+	self.assertFalse(q, q)
301	301
302	302		s.transact(createAndStuff)
303	303		s.close()

30	30		FAKE_POWER = 'fake power'
31	31		REAL_POWER = 'real power'
32	32
33		-
34	33		@implementer(IElectricityGrid)
35	34		class NullGrid(object):
36	35		"""

199	198
200	199
201	200
	201	+	@dependency.dependable
202	202		@empowerment(IAppliance)
203	203		@empowerment(IBreadConsumer)
204	204		class Toaster(Item):

230	230
231	231		def powerstripSetup(ps):
232	232		ps.setForUSElectricity()
	233	+
	234	+
	235	+	@dependency.dependable
233	236		class Blender(Item):
234	237		powerStrip = dependency.dependsOn(PowerStrip,
235	238		powerstripSetup)

277	282		"""
278	283		foo = Kitchen(store=self.store)
279	284		e = Toaster(store=self.store)
280		-	self.assertEquals(e.powerStrip, None)
	285	+	self.assertEqual(e.powerStrip, None)
281	286		dependency.installOn(e, foo)
282	287		e.toast()
283	288		ps = self.store.findUnique(PowerStrip, default=None)

331	336		f = Blender(store=self.store)
332	337		dependency.installOn(f, foo)
333	338
334		-	self.assertEquals(list(self.store.query(PowerStrip)), [ps])
	339	+	self.assertEqual(list(self.store.query(PowerStrip)), [ps])
335	340		#XXX does ordering matter?
336	341		self.assertEquals(set(dependency.installedDependents(ps, foo)),
337	342		{e, f})

341	346		[ps])
342	347
343	348		dependency.uninstallFrom(e, foo)
344		-	self.assertEquals(dependency.installedOn(ps), foo)
	349	+	self.assertEqual(dependency.installedOn(ps), foo)
345	350
346	351		dependency.uninstallFrom(f, foo)
347		-	self.assertEquals(dependency.installedOn(ps), None)
	352	+	self.assertEqual(dependency.installedOn(ps), None)
348	353
349	354		def test_installedUniqueRequirements(self):
350	355		"""

359	364		f = Blender(store=self.store)
360	365		dependency.installOn(f, foo)
361	366
362		-	self.assertEquals(list(dependency.installedUniqueRequirements(e, foo)),
	367	+	self.assertEqual(list(dependency.installedUniqueRequirements(e, foo)),
363	368		[bb])
364	369
365	370		def test_customizerCalledOnce(self):

390	395		dependency.installOn(e, foo)
391	396		self.assertEqual(e.powerStrip, ps)
392	397		dependency.uninstallFrom(e, foo)
393		-	self.assertEquals(dependency.installedOn(ps), foo)
	398	+	self.assertEqual(dependency.installedOn(ps), foo)
394	399
395	400		def test_doubleInstall(self):
396	401		"""

402	407		e = Toaster(store=self.store)
403	408		dependency.installOn(e, foo)
404	409		ps = PowerStrip(store=self.store)
405		-	self.failUnlessRaises(dependency.DependencyError,
	410	+	self.assertRaises(dependency.DependencyError,
406	411		dependency.installOn, ps, foo)
407	412		e2 = Toaster(store=self.store)
408	413		dependency.installOn(e2, foo)

419	424		blender = self.store.findUnique(Blender)
420	425		ps = self.store.findUnique(PowerStrip)
421	426
422		-	self.assertEquals(dependency.installedOn(blender), foo)
423		-	self.assertEquals(dependency.installedOn(ps), foo)
424		-	self.assertEquals(list(dependency.installedRequirements(ic, foo)),
	427	+	self.assertEqual(dependency.installedOn(blender), foo)
	428	+	self.assertEqual(dependency.installedOn(ps), foo)
	429	+	self.assertEqual(list(dependency.installedRequirements(ic, foo)),
425	430		[blender])
426	431
427	432		def test_recursiveUninstall(self):

437	442
438	443		dependency.uninstallFrom(ic, foo)
439	444
440		-	self.failIf(dependency.installedOn(blender))
441		-	self.failIf(dependency.installedOn(ps))
442		-	self.failIf(dependency.installedOn(ic))
	445	+	self.assertFalse(dependency.installedOn(blender))
	446	+	self.assertFalse(dependency.installedOn(ps))
	447	+	self.assertFalse(dependency.installedOn(ic))
443	448
444	449		def test_wrongDependsOn(self):
445	450		"""

465	470		f = Blender(store=self.store)
466	471		dependency.installOn(e, foo)
467	472		dependency.installOn(f, foo)
468		-	self.assertEquals(IAppliance(foo), e)
469		-	self.assertEquals(IBreadConsumer(foo), e)
	473	+	self.assertEqual(IAppliance(foo), e)
	474	+	self.assertEqual(IBreadConsumer(foo), e)
470	475		dependency.uninstallFrom(e, foo)
471		-	self.assertEquals(IAppliance(foo), f)
	476	+	self.assertEqual(IAppliance(foo), f)
472	477		dependency.uninstallFrom(f, foo)
473	478		self.assertRaises(TypeError, IAppliance, foo)
474	479

500	505		f = Toaster(store=self.store)
501	506		dependency.onlyInstallPowerups(e, foo)
502	507		dependency.onlyInstallPowerups(f, foo)
503		-	self.assertEquals(list(foo.powerupsFor(IBreadConsumer)), [e, f])
504		-	self.assertEquals(list(self.store.query(
	508	+	self.assertEqual(list(foo.powerupsFor(IBreadConsumer)), [e, f])
	509	+	self.assertEqual(list(self.store.query(
505	510		dependency._DependencyConnector)), [])
506	511
507	512

525	530		"""
526	531		dependency.installOn(RealGrid(store=self.store), self.store)
527	532		substore = SubStore.createNew(self.store, ['sub']).open()
528		-	self.assertEquals(PowerStrip(store=substore).draw(1), REAL_POWER)
	533	+	self.assertEqual(PowerStrip(store=substore).draw(1), REAL_POWER)
529	534
530	535
531	536		def test_requiresFromSiteDefault(self):

452	457		dependsOn should accept (most of) attributes.reference's args.
453	458		"""
454	459
455		-	self.failUnless("power source" in Toaster.powerStrip.doc)
456		-	self.assertEquals(Toaster.breadFactory.whenDeleted, reference.CASCADE)
	460	+	self.assertTrue("power source" in Toaster.powerStrip.doc)
	461	+	self.assertEqual(Toaster.breadFactory.whenDeleted, reference.CASCADE)
457	462
458	463		def test_powerupInterfaces(self):
459	464		"""

483	488		self.installCallbackCalled = False
484	489		e.callback = lambda _: setattr(self, 'installCallbackCalled', True)
485	490		dependency.installOn(e, foo)
486		-	self.failUnless(self.installCallbackCalled)
	491	+	self.assertTrue(self.installCallbackCalled)
487	492		self.uninstallCallbackCalled = False
488	493		e.callback = lambda _: setattr(self, 'uninstallCallbackCalled', True)
489	494		dependency.uninstallFrom(e, foo)
490		-	self.failUnless(self.uninstallCallbackCalled)
	495	+	self.assertTrue(self.uninstallCallbackCalled)
491	496
492	497
493	498		def test_onlyInstallPowerups(self):

536	541		"""
537	542		substore = SubStore.createNew(self.store, ['sub']).open()
538	543		ps = PowerStrip(store=substore)
539		-	self.assertEquals(ps.draw(1), FAKE_POWER)
540		-	self.assertEquals(ps.grid.siteStore, self.store)
	544	+	self.assertEqual(ps.draw(1), FAKE_POWER)
	545	+	self.assertEqual(ps.grid.siteStore, self.store)
541	546
542	547
543	548		def test_requiresFromSiteInSiteStore(self):

563	568		L{dependency.requiresFromSite}.
564	569		"""
565	570		plant = PowerPlant(store=self.store)
566		-	self.assertEquals(plant.grid.siteStore, self.store)
567		-	self.assertEquals(plant.grid.draw(100), FAKE_POWER)
	571	+	self.assertEqual(plant.grid.siteStore, self.store)
	572	+	self.assertEqual(plant.grid.draw(100), FAKE_POWER)
568	573		dependency.installOn(RealGrid(store=self.store), self.store)
569		-	self.assertEquals(plant.grid.siteStore, self.store)
570		-	self.assertEquals(plant.grid.draw(100), FAKE_POWER)
	574	+	self.assertEqual(plant.grid.siteStore, self.store)
	575	+	self.assertEqual(plant.grid.draw(100), FAKE_POWER)
571	576
572	577
573	578		def test_requiresFromSiteNoDefault(self):

577	582		"""
578	583		dependency.installOn(RealGrid(store=self.store), self.store)
579	584		substore = SubStore.createNew(self.store, ['sub']).open()
580		-	self.assertEquals(SpecifiedBadDefaults(store=substore).pump(),
	585	+	self.assertEqual(SpecifiedBadDefaults(store=substore).pump(),
581	586		REAL_POWER)
582	587
583	588

59	59		upgradeExplicitOid(store)
60	60
61	61		for substore in store.query(SubStore):
62		-	print('Upgrading: {!r}'.format(substore))
	62	+	print(u'Upgrading: {!r}'.format(substore))
63	63		self.upgradeStore(substore.open())
64	64
65	65		def perform(self, store, count):

72	72
73	73		try:
74	74		self.upgradeStore(store)
75		-	print('Upgrade complete')
	75	+	print(u'Upgrade complete')
76	76		except errors.ItemUpgradeError as e:
77		-	print('Upgrader error:')
	77	+	print(u'Upgrader error:')
78	78		e.originalFailure.printTraceback(file=sys.stdout)
79	79		print(self.errorMessageFormat % (
80	80		e.oldType.typeName, e.storeID, e.oldType.schemaVersion,

236	236		acc = None
237	237		for acc in self.store.query(userbase.LoginMethod):
238	238		if acc.domain is None:
239		-	print(acc.localpart, end='')
	239	+	print(acc.localpart, end=u'')
240	240		else:
241		-	print(acc.localpart + '@' + acc.domain, end='')
	241	+	print(acc.localpart + u'@' + acc.domain, end=u'')
242	242		if acc.account.disabled:
243		-	print(' [DISABLED]')
	243	+	print(u' [DISABLED]')
244	244		else:
245		-	print()
	245	+	print(u'')
246	246		if acc is None:
247		-	print('No accounts')
	247	+	print(u'No accounts')
248	248
249	249
250	250

1	1		import six
2	2		# -- test-case-name: axiom.test.test_slotmachine --
3	3
	4	+	import six
	5	+
4	6		hyper = super
5	7
6	8		_NOSLOT = object()

38	38
39	39		def testSanity(self):
40	40		store = Store()
41		-	for i in xrange(self.ntimes):
	41	+	for i in range(self.ntimes):
42	42		SimpleReferent(store=store, ref=Referee(store=store, topSecret=i))
43	43		(referee,) = list(store.query(Referee))
44	44		(referent,) = list(store.query(SimpleReferent))

Updating our web app

279	279		"""
280	280
281	281
282		-	LOCAL, REMOTE = range(2)
	282	+	LOCAL, REMOTE = list(range(2))
283	283		class IBatchProcessor(Interface):
284	284		def addReliableListener(listener, style=LOCAL):
285	285		"""

27	27		Shared part of file creation tests.
28	28		"""
29	29		f = s.newFile('test', 'whatever.txt')
30		-	f.write('crap')
	30	+	f.write(b'crap')
	31	+
31	32		def cb(fpath):
32		-	self.assertEquals(fpath.open().read(), 'crap')
	33	+	self.assertEqual(fpath.open().read(), b'crap')
33	34
34	35		return f.close().addCallback(cb)
35	36

70	71		npath = self.mktemp()
71	72		s = Store(spath)
72	73		rel = s.newFile("test", "123")
73		-	TEST_STR = "test 123"
	74	+	TEST_STR = b"test 123"
74	75
75	76		def cb(fpath):
76	77		fpath.setContent(TEST_STR)

83	84		s2 = Store(npath)
84	85		pti = list(s2.query(PathTesterItem))[0]
85	86
86		-	self.assertEquals(pti.relpath.getContent(),
	87	+	self.assertEqual(pti.relpath.getContent(),
87	88		TEST_STR)
88	89
89	90		return rel.close().addCallback(cb)

14	14		from axiom.item import Item
15	15		from axiom.attributes import reference, boolean, AND
16	16		from axiom.errors import ItemNotFound, DependencyError, UnsatisfiedRequirement
17		-	from six.moves import map
18		-	from six.moves import zip
	17	+	import six
	18	+	from six.moves import map, zip
19	19
20		-	#There is probably a cleaner way to do this.
21		-	_globalDependencyMap = {}
	20	+	# There is probably a cleaner way to do this.
	21	+	_globalDependencyMap = {
	22	+	# map depending-class: (depended-upon-class,
	23	+	# callable-to-customize-creation, reference-attribute)
	24	+	}
22	25
23	26		def dependentsOf(cls):
24	27		deps = _globalDependencyMap.get(cls, None)

60	63		raise TypeError("dependsOn can be used only from a class definition.")
61	64		ref = reference(reftype=itemType, doc=doc, indexed=indexed, allowNone=True,
62	65		whenDeleted=whenDeleted)
63		-	if "__dependsOn_advice_data__" not in locals:
64		-	addClassAdvisor(_dependsOn_advice)
	66	+	if "__dependsOn_advice_data__" not in locals and six.PY2:
	67	+	addClassAdvisor(dependable)
65	68		locals.setdefault('__dependsOn_advice_data__', []).append(
66		-	(itemType, itemCustomizer, ref))
	69	+	(itemType, itemCustomizer, ref)
	70	+	)
67	71		return ref
68	72
69		-	def _dependsOn_advice(cls):
	73	+
	74	+	def dependable(cls):
	75	+	"""
	76	+	Classes that use `dependsOn` in their bodies should be decorated with this
	77	+	as a class decorator, like so::
	78	+
	79	+	@dependable
	80	+	class A(Item):
	81	+	b = dependsOn(B)
	82	+	"""
70	83		if cls in _globalDependencyMap:
71		-	print("Double advising of %s. dependency map from first time: %s" % (
72		-	cls, _globalDependencyMap[cls]))
73		-	#bail if we end up here twice, somehow
	84	+	# bail if we end up here twice, somehow
74	85		return cls
75	86		for itemType, itemCustomizer, ref in cls.__dict__[
76		-	'__dependsOn_advice_data__']:
	87	+	'__dependsOn_advice_data__'
	88	+	]:
77	89		classDependsOn(cls, itemType, itemCustomizer, ref)
78	90		del cls.__dependsOn_advice_data__
79	91		return cls
80	92
	93	+
81	94		def classDependsOn(cls, itemType, itemCustomizer, ref):
82	95		_globalDependencyMap.setdefault(cls, []).append(
83	96		(itemType, itemCustomizer, ref))

119	132		if (dc.installee.__class__ == self.__class__
120	133		and self.__class__ in set(
121	134		itertools.chain([blob[0][0] for blob in
122		-	_globalDependencyMap.values()]))):
	135	+	list(_globalDependencyMap.values())]))):
123	136		#Somebody got here before we did... let's punt
124	137		raise DependencyError("An instance of %r is already "
125	138		"installed on %r." % (self.__class__,

1	1
2		-	import operator, random
	2	+	import operator, random, six
3	3
4	4		from twisted.trial.unittest import TestCase
5	5

71	71		"""
72	72		s = Store()
73	73		comparison = (A.reftoc == B.storeID)
74		-	self.assertEquals(
	74	+	self.assertEqual(
75	75		comparison.getQuery(s),
76	76		'({}.[reftoc] = {}.oid)'.format(
77	77		A.getTableName(s),
78	78		B.getTableName(s)))
79		-	self.assertEquals(comparison.getArgs(s), [])
	79	+	self.assertEqual(comparison.getArgs(s), [])
80	80
81	81
82	82		def test_leftHandStoreIDComparison(self):

87	87		"""
88	88		s = Store()
89	89		comparison = (B.storeID == A.reftoc)
90		-	self.assertEquals(
	90	+	self.assertEqual(
91	91		comparison.getQuery(s),
92	92		'({}.oid = {}.[reftoc])'.format(
93	93		B.getTableName(s),
94	94		A.getTableName(s)))
95		-	self.assertEquals(comparison.getArgs(s), [])
	95	+	self.assertEqual(comparison.getArgs(s), [])
96	96
97	97
98	98		def test_simplestQuery(self):