sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_empty.py

@@ -0,0 +1,22 @@
+import pytest
+from sqlobject import SQLObject
+from sqlobject.tests.dbtest import setupClass, supports
+
+
+class EmptyClass(SQLObject):
+
+    pass
+
+
+def test_empty():
+    if not supports('emptyTable'):
+        pytest.skip("emptyTable isn't supported")
+    setupClass(EmptyClass)
+    e1 = EmptyClass()
+    e2 = EmptyClass()
+    assert e1 != e2
+    assert e1.id != e2.id
+    assert e1 in list(EmptyClass.select())
+    assert e2 in list(EmptyClass.select())
+    e1.destroySelf()
+    assert list(EmptyClass.select()) == [e2]

sqlobject/tests/test_enum.py

@@ -0,0 +1,75 @@
+from sqlobject import EnumCol, SQLObject, UnicodeCol
+from sqlobject.col import validators
+from sqlobject.tests.dbtest import raises, setupClass
+
+
+########################################
+# Enum test
+########################################
+
+
+class Enum1(SQLObject):
+
+    cl = EnumCol(enumValues=['a', 'bcd', 'e'])
+
+
+def testBad():
+    setupClass(Enum1)
+    for _l in ['a', 'bcd', 'a', 'e']:
+        Enum1(cl=_l)
+    raises(
+        (Enum1._connection.module.IntegrityError,
+         Enum1._connection.module.ProgrammingError,
+         validators.Invalid),
+        Enum1, cl='b')
+
+
+class EnumWithNone(SQLObject):
+
+    cl = EnumCol(enumValues=['a', 'bcd', 'e', None])
+
+
+def testNone():
+    setupClass(EnumWithNone)
+    for _l in [None, 'a', 'bcd', 'a', 'e', None]:
+        e = EnumWithNone(cl=_l)
+        assert e.cl == _l
+
+
+class EnumWithDefaultNone(SQLObject):
+
+    cl = EnumCol(enumValues=['a', 'bcd', 'e', None], default=None)
+
+
+def testDefaultNone():
+    setupClass(EnumWithDefaultNone)
+
+    e = EnumWithDefaultNone()
+    assert e.cl is None
+
+
+class EnumWithDefaultOther(SQLObject):
+
+    cl = EnumCol(enumValues=['a', 'bcd', 'e', None], default='a')
+
+
+def testDefaultOther():
+    setupClass(EnumWithDefaultOther)
+
+    e = EnumWithDefaultOther()
+    assert e.cl == 'a'
+
+
+class EnumUnicode(SQLObject):
+
+    n = UnicodeCol()
+    cl = EnumCol(enumValues=['a', 'b'])
+
+
+def testUnicode():
+    setupClass(EnumUnicode)
+
+    EnumUnicode(n=u'a', cl='a')
+    EnumUnicode(n=u'b', cl=u'b')
+    EnumUnicode(n=u'\u201c', cl='a')
+    EnumUnicode(n=u'\u201c', cl=u'b')

sqlobject/tests/test_events.py

@@ -0,0 +1,142 @@
+from __future__ import print_function
+
+from sqlobject import IntCol, SQLObject, StringCol, events
+from sqlobject.inheritance import InheritableSQLObject
+from sqlobject.tests.dbtest import setupClass
+
+
+class EventTester(SQLObject):
+    name = StringCol()
+
+
+def make_watcher():
+    log = []
+
+    def watch(*args):
+        log.append(args)
+
+    watch.log = log
+    return watch
+
+
+def make_listen(signal, cls=None):
+    if cls is None:
+        cls = EventTester
+    watcher = make_watcher()
+    events.listen(watcher, cls, signal)
+    return watcher
+
+
+def test_create():
+    watcher = make_listen(events.ClassCreateSignal)
+
+    class EventTesterSub1(EventTester):
+        pass
+
+    class EventTesterSub2(EventTesterSub1):
+        pass
+
+    assert len(watcher.log) == 2
+    assert len(watcher.log[0]) == 5
+    assert watcher.log[0][0] == 'EventTesterSub1'
+    assert watcher.log[0][1] == (EventTester,)
+    assert isinstance(watcher.log[0][2], dict)
+    assert isinstance(watcher.log[0][3], list)
+
+
+def test_row_create():
+    setupClass(EventTester)
+    watcher = make_listen(events.RowCreateSignal)
+    row1 = EventTester(name='foo')
+    row2 = EventTester(name='bar')
+    assert len(watcher.log) == 2
+    assert watcher.log == [
+        (row1, {'name': 'foo'}, []),
+        (row2, {'name': 'bar'}, [])]
+
+
+def test_row_destroy():
+    setupClass(EventTester)
+    watcher = make_listen(events.RowDestroySignal)
+    f = EventTester(name='foo')
+    assert not watcher.log
+    f.destroySelf()
+    assert watcher.log == [(f, [])]
+
+
+def test_row_destroyed():
+    setupClass(EventTester)
+    watcher = make_listen(events.RowDestroyedSignal)
+    f = EventTester(name='foo')
+    assert not watcher.log
+    f.destroySelf()
+    assert watcher.log == [(f, [])]
+
+
+def test_row_update():
+    setupClass(EventTester)
+    watcher = make_listen(events.RowUpdateSignal)
+    f = EventTester(name='bar')
+    assert not watcher.log
+    f.name = 'bar2'
+    f.set(name='bar3')
+    assert watcher.log == [
+        (f, {'name': 'bar2'}),
+        (f, {'name': 'bar3'})]
+
+
+def test_row_updated():
+    setupClass(EventTester)
+    watcher = make_listen(events.RowUpdatedSignal)
+    f = EventTester(name='bar')
+    assert not watcher.log
+    f.name = 'bar2'
+    f.set(name='bar3')
+    assert watcher.log == [(f, []), (f, [])]
+
+
+def test_add_column():
+    setupClass(EventTester)
+    watcher = make_listen(events.AddColumnSignal)
+    events.summarize_events_by_sender()
+
+    class NewEventTester(EventTester):
+        name2 = StringCol()
+
+    expect = (
+        NewEventTester, None,
+        'name2', NewEventTester.sqlmeta.columnDefinitions['name2'],
+        False, [])
+    print(zip(watcher.log[1], expect))
+    assert watcher.log[1] == expect
+
+
+class InheritableEventTestA(InheritableSQLObject):
+    a = IntCol()
+
+
+class InheritableEventTestB(InheritableEventTestA):
+    b = IntCol()
+
+
+class InheritableEventTestC(InheritableEventTestB):
+    c = IntCol()
+
+
+def _query(instance):
+    row = InheritableEventTestA.get(instance.id)
+    assert isinstance(row, InheritableEventTestC)
+    assert row.c == 3
+
+
+def _signal(instance, kwargs, postfuncs):
+    postfuncs.append(_query)
+
+
+def test_inheritance_row_created():
+    setupClass([InheritableEventTestA, InheritableEventTestB,
+                InheritableEventTestC])
+
+    events.listen(_signal, InheritableEventTestA, events.RowCreatedSignal)
+
+    InheritableEventTestC(a=1, b=2, c=3)

sqlobject/tests/test_exceptions.py

@@ -0,0 +1,40 @@
+import pytest
+from sqlobject import SQLObject, StringCol
+from sqlobject.dberrors import DatabaseError, DuplicateEntryError, \
+    OperationalError, ProgrammingError
+from sqlobject.tests.dbtest import getConnection, raises, setupClass, supports
+
+
+########################################
+# Table aliases and self-joins
+########################################
+
+
+class SOTestException(SQLObject):
+    name = StringCol(unique=True, length=100)
+
+
+class SOTestExceptionWithNonexistingTable(SQLObject):
+    pass
+
+
+def test_exceptions():
+    if not supports("exceptions"):
+        pytest.skip("exceptions aren't supported")
+    setupClass(SOTestException)
+    SOTestException(name="test")
+    raises(DuplicateEntryError, SOTestException, name="test")
+
+    connection = getConnection()
+    SOTestExceptionWithNonexistingTable.setConnection(connection)
+    try:
+        list(SOTestExceptionWithNonexistingTable.select())
+    except ProgrammingError as e:
+        assert e.args[0].code in (1146, '42P01')
+    except OperationalError:
+        assert connection.dbName == 'sqlite'
+    except DatabaseError:
+        assert connection.dbName == 'postgres' \
+            and connection.driver == 'pg8000'
+    else:
+        assert False, "DID NOT RAISE"

sqlobject/tests/test_expire.py

@@ -0,0 +1,29 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Expiring, syncing
+########################################
+
+
+class SyncTest(SQLObject):
+    name = StringCol(length=50, alternateID=True, dbName='name_col')
+
+
+def test_expire():
+    setupClass(SyncTest)
+    SyncTest(name='bob')
+    SyncTest(name='tim')
+
+    conn = SyncTest._connection
+    b = SyncTest.byName('bob')
+    conn.query("UPDATE sync_test SET name_col = 'robert' WHERE id = %i"
+               % b.id)
+    assert b.name == 'bob'
+    b.expire()
+    assert b.name == 'robert'
+    conn.query("UPDATE sync_test SET name_col = 'bobby' WHERE id = %i"
+               % b.id)
+    b.sync()
+    assert b.name == 'bobby'

sqlobject/tests/test_groupBy.py

@@ -0,0 +1,45 @@
+from sqlobject import IntCol, SQLObject, StringCol
+from sqlobject.sqlbuilder import Select, func
+from sqlobject.tests.dbtest import getConnection, setupClass
+
+
+########################################
+# groupBy
+########################################
+
+
+class GroupbyTest(SQLObject):
+    name = StringCol()
+    so_value = IntCol()
+
+
+def test_groupBy():
+    setupClass(GroupbyTest)
+    GroupbyTest(name='a', so_value=1)
+    GroupbyTest(name='a', so_value=2)
+    GroupbyTest(name='b', so_value=1)
+
+    connection = getConnection()
+    select = Select(
+        [GroupbyTest.q.name, func.COUNT(GroupbyTest.q.so_value)],
+        groupBy=GroupbyTest.q.name,
+        orderBy=GroupbyTest.q.name)
+    sql = connection.sqlrepr(select)
+    rows = list(connection.queryAll(sql))
+    assert [tuple(t) for t in rows] == [('a', 2), ('b', 1)]
+
+
+def test_groupBy_list():
+    setupClass(GroupbyTest)
+    GroupbyTest(name='a', so_value=1)
+    GroupbyTest(name='a', so_value=2)
+    GroupbyTest(name='b', so_value=1)
+
+    connection = getConnection()
+    select = Select(
+        [GroupbyTest.q.name, GroupbyTest.q.so_value],
+        groupBy=[GroupbyTest.q.name, GroupbyTest.q.so_value],
+        orderBy=[GroupbyTest.q.name, GroupbyTest.q.so_value])
+    sql = connection.sqlrepr(select)
+    rows = list(connection.queryAll(sql))
+    assert [tuple(t) for t in rows] == [('a', 1), ('a', 2), ('b', 1)]

sqlobject/tests/test_identity.py

@@ -0,0 +1,29 @@
+from sqlobject import IntCol, SQLObject
+from sqlobject.tests.dbtest import getConnection, setupClass
+
+
+########################################
+# Identity (MS SQL)
+########################################
+
+
+class SOTestIdentity(SQLObject):
+    n = IntCol()
+
+
+def test_identity():
+    # (re)create table
+    SOTestIdentity.dropTable(connection=getConnection(), ifExists=True)
+    setupClass(SOTestIdentity)
+
+    # insert without giving identity
+    SOTestIdentity(n=100)  # i1
+    # verify result
+    i1get = SOTestIdentity.get(1)
+    assert (i1get.n == 100)
+
+    # insert while giving identity
+    SOTestIdentity(id=2, n=200)  # i2
+    # verify result
+    i2get = SOTestIdentity.get(2)
+    assert (i2get.n == 200)

sqlobject/tests/test_indexes.py

@@ -0,0 +1,100 @@
+import pytest
+from sqlobject import DatabaseIndex, ForeignKey, IntCol, MultipleJoin, \
+    SQLObject, StringCol
+from sqlobject.dberrors import DatabaseError, IntegrityError, \
+    OperationalError, ProgrammingError
+from sqlobject.tests.dbtest import raises, setupClass, supports
+
+
+########################################
+# Indexes
+########################################
+
+
+class SOIndex1(SQLObject):
+    name = StringCol(length=100)
+    number = IntCol()
+
+    nameIndex = DatabaseIndex('name', unique=True)
+    nameIndex2 = DatabaseIndex(name, number)
+    nameIndex3 = DatabaseIndex({'column': name,
+                                'length': 3})
+
+
+class SOIndex2(SQLObject):
+    name = StringCol(length=100)
+    nameIndex = DatabaseIndex({'expression': 'lower(name)'})
+
+
+def test_indexes_1():
+    setupClass(SOIndex1)
+    n = 0
+    for name in 'blah blech boring yep yort snort'.split():
+        n += 1
+        SOIndex1(name=name, number=n)
+    mod = SOIndex1._connection.module
+    raises(
+        (mod.ProgrammingError, mod.IntegrityError,
+         mod.OperationalError, mod.DatabaseError,
+         ProgrammingError, IntegrityError, OperationalError, DatabaseError),
+        SOIndex1, name='blah', number=0)
+
+
+def test_indexes_2():
+    if not supports('expressionIndex'):
+        pytest.skip("expressionIndex isn't supported")
+    setupClass(SOIndex2)
+    SOIndex2(name='')
+
+
+class PersonIndexGet(SQLObject):
+    firstName = StringCol(length=100)
+    lastName = StringCol(length=100)
+    age = IntCol(alternateID=True)
+    nameIndex = DatabaseIndex(firstName, lastName, unique=True)
+
+
+def test_index_get_1():
+    setupClass(PersonIndexGet, force=True)
+
+    PersonIndexGet(firstName='Eric', lastName='Idle', age=62)
+    PersonIndexGet(firstName='Terry', lastName='Gilliam', age=65)
+    PersonIndexGet(firstName='John', lastName='Cleese', age=66)
+
+    PersonIndexGet.get(1)
+    PersonIndexGet.nameIndex.get('Terry', 'Gilliam')
+    PersonIndexGet.nameIndex.get(firstName='John', lastName='Cleese')
+
+    raises(Exception, PersonIndexGet.nameIndex.get,
+           firstName='Graham', lastName='Chapman')
+
+    raises(Exception, PersonIndexGet.nameIndex.get,
+           'Terry', lastName='Gilliam')
+
+    raises(Exception, PersonIndexGet.nameIndex.get, 'Terry', 'Gilliam', 65)
+
+    raises(Exception, PersonIndexGet.nameIndex.get, 'Terry')
+
+
+class PersonIndexGet2(SQLObject):
+    name = StringCol(alternateID=True, length=100)
+    age = IntCol()
+    addresses = MultipleJoin('AddressIndexGet2')
+
+
+class AddressIndexGet2(SQLObject):
+    person = ForeignKey('PersonIndexGet2', notNone=True)
+    type = StringCol(notNone=True, length=100)
+    street = StringCol(notNone=True)
+    pk = DatabaseIndex(person, type, unique=True)
+
+
+def test_index_get_2():
+    setupClass([PersonIndexGet2, AddressIndexGet2])
+
+    p = PersonIndexGet2(name='Terry Guilliam', age=64)
+    AddressIndexGet2(person=p, type='home', street='Terry Street 234')
+    AddressIndexGet2(person=p, type='work', street='Guilliam Street 234')
+
+    AddressIndexGet2.pk.get(p, 'work')
+    AddressIndexGet2.pk.get(person=p, type='work')

sqlobject/tests/test_inheritance.py

@@ -0,0 +1,35 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Inheritance
+########################################
+
+
+class Super(SQLObject):
+
+    name = StringCol(length=10)
+
+
+class Sub(Super):
+
+    name2 = StringCol(length=10)
+
+
+def test_super():
+    setupClass(Super)
+    setupClass(Sub)
+    s1 = Super(name='one')
+    Super(name='two')  # s2
+    s3 = Super.get(s1.id)
+    assert s1 == s3
+
+
+def test_sub():
+    setupClass(Super)
+    setupClass(Sub)
+    s1 = Sub(name='one', name2='1')
+    Sub(name='two', name2='2')  # s2
+    s3 = Sub.get(s1.id)
+    assert s1 == s3

sqlobject/tests/test_joins.py

@@ -0,0 +1,160 @@
+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