from sqlobject import *
from dbtest import *

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

class PersonJoinerNew(SQLObject):

    name = StringCol(length=40)
    addressJoiners = ManyToMany('AddressJoinerNew')

class AddressJoinerNew(SQLObject):

    zip = StringCol(length=5)
    personJoiners = ManyToMany('PersonJoinerNew')

class ImplicitJoiningSONew(SQLObject):
    foo = ManyToMany('Bar')

class ExplicitJoiningSONew(SQLObject):
    foo = OneToMany('Bar')

class TestJoin:

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

    def test_join(self):
        b = PersonJoinerNew.get(name='bob')
        assert list(b.addressJoiners) == []
        z = AddressJoinerNew.get(zip='11111')
        b.addressJoiners.add(z)
        self.assertZipsEqual(b.addressJoiners, ['11111'])
        print str(z.personJoiners), repr(z.personJoiners)
        self.assertNamesEqual(z.personJoiners, ['bob'])
        z2 = AddressJoinerNew.get(zip='22222')
        b.addressJoiners.add(z2)
        print str(b.addressJoiners)
        self.assertZipsEqual(b.addressJoiners, ['11111', '22222'])
        self.assertNamesEqual(z2.personJoiners, ['bob'])
        b.addressJoiners.remove(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(ImplicitJoiningSONew, 'foo')
        assert not hasattr(ImplicitJoiningSONew, 'bars')

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


class PersonJoinerNew2(SQLObject):

    name = StringCol('name', length=40, alternateID=True)
    addressJoiner2s = OneToMany('AddressJoinerNew2',
                                join_column='personJoinerNew2')

class AddressJoinerNew2(SQLObject):

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

    zip = StringCol(length=5)
    plus4 = StringCol(length=4, default=None)
    personJoinerNew2 = ForeignKey('PersonJoinerNew2')

class TestJoin2:

    def setup_method(self, meth):
        setup_class(PersonJoinerNew2, AddressJoinerNew2)
        p1 = PersonJoinerNew2(name='bob')
        p2 = PersonJoinerNew2(name='sally')
        for z in ['11111', '22222', '33333']:
            a = AddressJoinerNew2(zip=z, personJoinerNew2=p1)
            #p1.addAddressJoinerNew2(a)
        AddressJoinerNew2(zip='00000', personJoinerNew2=p2)

    def test_basic(self):
        bob = PersonJoinerNew2.get(name='bob')
        sally = PersonJoinerNew2.get(name='sally')
        print bob.addressJoiner2s
        print bob
        assert len(list(bob.addressJoiner2s)) == 3
        assert len(list(sally.addressJoiner2s)) == 1
        bob.addressJoiner2s[0].destroy_self()
        assert len(list(bob.addressJoiner2s)) == 2
        z = bob.addressJoiner2s[0]
        z.zip = 'xxxxx'
        id = z.id
        del z
        z = AddressJoinerNew2.get(id)
        assert z.zip == 'xxxxx'

    def test_defaultOrder(self):
        p1 = PersonJoinerNew2.get(name='bob')
        assert (sorted([i.zip for i in p1.addressJoiner2s])
                == ['11111', '22222', '33333'])