sqlobject.tests.test_joins — SQLObject 3.9.1 documentation

# Source code for sqlobject.tests.test_joins

    from sqlobject import ForeignKey, MultipleJoin, RelatedJoin, SQLObject, \
        StringCol
    from sqlobject.tests.dbtest import setupClass

    ########################################
    # Joins
    ########################################

    class PersonJoiner(SQLObject):

        name = StringCol(length=40, alternateID=True)
        addressJoiners = RelatedJoin('AddressJoiner')

    class AddressJoiner(SQLObject):

        zip = StringCol(length=5, alternateID=True)
        personJoiners = RelatedJoin('PersonJoiner')

    class ImplicitJoiningSO(SQLObject):
        foo = RelatedJoin('Bar')

    class ExplicitJoiningSO(SQLObject):
        foo = MultipleJoin('Bar', joinMethodName='foo')

    class TestJoin:

        def setup_method(self, meth):
            setupClass(PersonJoiner)
            setupClass(AddressJoiner)
            for n in ['bob', 'tim', 'jane', 'joe', 'fred', 'barb']:
                PersonJoiner(name=n)
            for z in ['11111', '22222', '33333', '44444']:
                AddressJoiner(zip=z)

        def test_join(self):
            b = PersonJoiner.byName('bob')
            assert b.addressJoiners == []
            z = AddressJoiner.byZip('11111')
            b.addAddressJoiner(z)
            self.assertZipsEqual(b.addressJoiners, ['11111'])
            self.assertNamesEqual(z.personJoiners, ['bob'])
            z2 = AddressJoiner.byZip('22222')
            b.addAddressJoiner(z2)
            self.assertZipsEqual(b.addressJoiners, ['11111', '22222'])
            self.assertNamesEqual(z2.personJoiners, ['bob'])
            b.removeAddressJoiner(z)
            self.assertZipsEqual(b.addressJoiners, ['22222'])
            self.assertNamesEqual(z.personJoiners, [])

        def assertZipsEqual(self, zips, dest):
            assert [a.zip for a in zips] == dest

        def assertNamesEqual(self, people, dest):
            assert [p.name for p in people] == dest

        def test_joinAttributeWithUnderscores(self):
            # Make sure that the implicit setting of joinMethodName works
            assert hasattr(ImplicitJoiningSO, 'foo')
            assert not hasattr(ImplicitJoiningSO, 'bars')

            # And make sure explicit setting also works
            assert hasattr(ExplicitJoiningSO, 'foo')
            assert not hasattr(ExplicitJoiningSO, 'bars')

    class PersonJoiner2(SQLObject):

        name = StringCol('name', length=40, alternateID=True)
        addressJoiner2s = MultipleJoin('AddressJoiner2')

    class AddressJoiner2(SQLObject):

        class sqlmeta:
            defaultOrder = ['-zip', 'plus4']

        zip = StringCol(length=5)
        plus4 = StringCol(length=4, default=None)
        personJoiner2 = ForeignKey('PersonJoiner2')

    class TestJoin2:

        def setup_method(self, meth):
            setupClass([PersonJoiner2, AddressJoiner2])
            p1 = PersonJoiner2(name='bob')
            p2 = PersonJoiner2(name='sally')
            for z in ['11111', '22222', '33333']:
                AddressJoiner2(zip=z, personJoiner2=p1)
            AddressJoiner2(zip='00000', personJoiner2=p2)

        def test_basic(self):
            bob = PersonJoiner2.byName('bob')
            sally = PersonJoiner2.byName('sally')
            assert len(bob.addressJoiner2s) == 3
            assert len(sally.addressJoiner2s) == 1
            bob.addressJoiner2s[0].destroySelf()
            assert len(bob.addressJoiner2s) == 2
            z = bob.addressJoiner2s[0]
            z.zip = 'xxxxx'
            id = z.id
            del z
            z = AddressJoiner2.get(id)
            assert z.zip == 'xxxxx'

        def test_defaultOrder(self):
            p1 = PersonJoiner2.byName('bob')
            assert ([i.zip for i in p1.addressJoiner2s]
                    == ['33333', '22222', '11111'])

    _personJoiner3_getters = []
    _personJoiner3_setters = []

    class PersonJoiner3(SQLObject):

        name = StringCol('name', length=40, alternateID=True)
        addressJoiner3s = MultipleJoin('AddressJoiner3')

    class AddressJoiner3(SQLObject):

        zip = StringCol(length=5)
        personJoiner3 = ForeignKey('PersonJoiner3')

        def _get_personJoiner3(self):
            value = self._SO_get_personJoiner3()
            _personJoiner3_getters.append((self, value))
            return value

        def _set_personJoiner3(self, value):
            self._SO_set_personJoiner3(value)
            _personJoiner3_setters.append((self, value))

    class TestJoin3:

        def setup_method(self, meth):
            setupClass([PersonJoiner3, AddressJoiner3])
            p1 = PersonJoiner3(name='bob')
            p2 = PersonJoiner3(name='sally')
            for z in ['11111', '22222', '33333']:
                AddressJoiner3(zip=z, personJoiner3=p1)
            AddressJoiner3(zip='00000', personJoiner3=p2)

        def test_accessors(self):
            assert len(_personJoiner3_getters) == 0
            assert len(_personJoiner3_setters) == 4
            bob = PersonJoiner3.byName('bob')
            for addressJoiner3 in bob.addressJoiner3s:
                addressJoiner3.personJoiner3
            assert len(_personJoiner3_getters) == 3
            assert len(_personJoiner3_setters) == 4