sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_transactions.py

@@ -0,0 +1,122 @@
+import pytest
+from sqlobject import SQLObject, SQLObjectNotFound, StringCol
+from sqlobject.tests.dbtest import raises, setupClass, supports
+from sqlobject import events
+from sqlobject.main import sqlmeta
+
+########################################
+# Transaction test
+########################################
+
+
+try:
+    support_transactions = supports('transactions')
+except NameError:
+    # The module was imported during documentation building
+    pass
+else:
+    if not support_transactions:
+        pytestmark = pytest.mark.skip("These tests require transactions")
+
+
+class SOTestSOTrans(SQLObject):
+    class sqlmeta:
+        defaultOrder = 'name'
+    name = StringCol(length=10, alternateID=True, dbName='name_col')
+
+
+def make_watcher():
+    log = []
+
+    def watch(*args):
+        log.append(args)
+
+    watch.log = log
+    return watch
+
+
+def make_listen(signal):
+    watcher = make_watcher()
+    events.listen(watcher, sqlmeta, signal)
+    return watcher
+
+
+def test_transaction():
+    commit_watcher = make_listen(events.CommitSignal)
+    rollback_watcher = make_listen(events.RollbackSignal)
+    setupClass(SOTestSOTrans)
+    SOTestSOTrans(name='bob')
+    SOTestSOTrans(name='tim')
+    trans = SOTestSOTrans._connection.transaction()
+    try:
+        SOTestSOTrans._connection.autoCommit = 'exception'
+        SOTestSOTrans(name='joe', connection=trans)
+        trans.rollback()
+        trans.begin()
+        assert ([n.name for n in SOTestSOTrans.select(connection=trans)]
+                == ['bob', 'tim'])
+        b = SOTestSOTrans.byName('bob', connection=trans)
+        b.name = 'robert'
+        trans.commit()
+        assert b.name == 'robert'
+        b.name = 'bob'
+        trans.rollback()
+        trans.begin()
+        assert b.name == 'robert'
+        assert len(commit_watcher.log) == 1
+        assert commit_watcher.log[0][0][0][0] == 'SOTestSOTrans'
+        assert commit_watcher.log[0][0][0][1] == [1, 2]
+        assert len(rollback_watcher.log) == 2
+        assert rollback_watcher.log[0][0][0][0] == 'SOTestSOTrans'
+        assert rollback_watcher.log[0][0][0][1] == [3]
+        assert rollback_watcher.log[1][0][0][0] == 'SOTestSOTrans'
+        assert rollback_watcher.log[1][0][0][1] == [1, 2]
+    finally:
+        SOTestSOTrans._connection.autoCommit = True
+
+
+def test_transaction_commit_sync():
+    setupClass(SOTestSOTrans)
+    connection = SOTestSOTrans._connection
+    trans = connection.transaction()
+    try:
+        SOTestSOTrans(name='bob')
+        bOut = SOTestSOTrans.byName('bob')
+        bIn = SOTestSOTrans.byName('bob', connection=trans)
+        bIn.name = 'robert'
+        assert bOut.name == 'bob'
+        trans.commit()
+        assert bOut.name == 'robert'
+    finally:
+        trans.rollback()
+        connection.autoCommit = True
+        connection.close()
+
+
+def test_transaction_delete(close=False):
+    setupClass(SOTestSOTrans)
+    connection = SOTestSOTrans._connection
+    if (connection.dbName == 'sqlite') and connection._memory:
+        pytest.skip("The test doesn't work with sqlite memory connection")
+    trans = connection.transaction()
+    try:
+        SOTestSOTrans(name='bob')
+        bIn = SOTestSOTrans.byName('bob', connection=trans)
+        bIn.destroySelf()
+        bOut = SOTestSOTrans.select(SOTestSOTrans.q.name == 'bob')
+        assert bOut.count() == 1
+        bOutInst = bOut[0]
+        bOutID = bOutInst.id  # noqa: bOutID is used in the string code below
+        trans.commit(close=close)
+        assert bOut.count() == 0
+        raises(SQLObjectNotFound, SOTestSOTrans.get, bOutID)
+        with raises(SQLObjectNotFound):
+            bOutInst.name
+    finally:
+        trans.rollback()
+        connection.autoCommit = True
+        connection.close()
+
+
+def test_transaction_delete_with_close():
+    test_transaction_delete(close=True)

sqlobject/tests/test_unicode.py

@@ -0,0 +1,84 @@
+from sqlobject import IntCol, SQLObject, UnicodeCol
+from sqlobject.compat import PY2
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Unicode columns
+########################################
+
+
+class SOTestUnicode(SQLObject):
+    so_count = IntCol(alternateID=True)
+    col = UnicodeCol(alternateID=True, length=100)
+
+
+data = [u'\u00f0', u'test', 'ascii test']
+items = []
+
+
+def setup():
+    global items
+    items = []
+    setupClass(SOTestUnicode)
+    for i, s in enumerate(data):
+        items.append(SOTestUnicode(so_count=i, col=s))
+
+
+def test_create():
+    setup()
+    for s, item in zip(data, items):
+        assert item.col == s
+
+    conn = SOTestUnicode._connection
+    if PY2:
+        rows = conn.queryAll("""
+        SELECT so_count, col
+        FROM so_test_unicode
+        ORDER BY so_count
+        """)
+        for so_count, col in rows:
+            if not isinstance(col, bytes):
+                col = col.encode('utf-8')
+            assert data[so_count].encode('utf-8') == col
+    else:
+        rows = conn.queryAll("""
+        SELECT so_count, col
+        FROM so_test_unicode
+        ORDER BY so_count
+        """)
+        # On python 3, everthings already decoded to unicode
+        for so_count, col in rows:
+            assert data[so_count] == col
+
+
+def test_select():
+    setup()
+    for i, value in enumerate(data):
+        rows = list(SOTestUnicode.select(SOTestUnicode.q.col == value))
+        assert len(rows) == 1
+        if PY2:
+            rows = list(SOTestUnicode.select(SOTestUnicode.q.col == value))
+            assert len(rows) == 1
+        rows = list(SOTestUnicode.selectBy(col=value))
+        assert len(rows) == 1
+        if PY2:
+            rows = list(SOTestUnicode.selectBy(col=value))
+            assert len(rows) == 1
+        row = SOTestUnicode.byCol(value)
+        assert row.so_count == i
+
+    # starts/endswith/contains
+    rows = list(SOTestUnicode.select(SOTestUnicode.q.col.startswith("test")))
+    assert len(rows) == 1
+    rows = list(SOTestUnicode.select(SOTestUnicode.q.col.endswith("test")))
+    assert len(rows) == 2
+    rows = list(SOTestUnicode.select(SOTestUnicode.q.col.contains("test")))
+    assert len(rows) == 2
+    rows = list(SOTestUnicode.select(
+        SOTestUnicode.q.col.startswith(u"\u00f0")))
+    assert len(rows) == 1
+    rows = list(SOTestUnicode.select(SOTestUnicode.q.col.endswith(u"\u00f0")))
+    assert len(rows) == 1
+    rows = list(SOTestUnicode.select(SOTestUnicode.q.col.contains(u"\u00f0")))
+    assert len(rows) == 1

sqlobject/tests/test_uuidcol.py

@@ -0,0 +1,40 @@
+from uuid import UUID
+from sqlobject import SQLObject, UuidCol
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Uuid columns
+########################################
+
+
+testuuid = UUID('7e3b5c1e-3402-4b10-a3c6-8ee6dbac7d1a')
+
+
+class UuidContainer(SQLObject):
+    uuiddata = UuidCol(alternateID=True, default=None)
+
+
+def test_uuidCol():
+    setupClass([UuidContainer])
+
+    my_uuid = UuidContainer(uuiddata=testuuid)
+    iid = my_uuid.id
+
+    UuidContainer._connection.cache.clear()
+
+    my_uuid_2 = UuidContainer.get(iid)
+
+    assert my_uuid_2.uuiddata == testuuid
+
+
+def test_alternate_id():
+    setupClass([UuidContainer])
+
+    UuidContainer(uuiddata=testuuid)
+
+    UuidContainer._connection.cache.clear()
+
+    my_uuid_2 = UuidContainer.byUuiddata(testuuid)
+
+    assert my_uuid_2.uuiddata == testuuid

sqlobject/tests/test_validation.py

@@ -0,0 +1,125 @@
+from sqlobject import BoolCol, FloatCol, IntCol, PickleCol, SQLObject, \
+    StringCol, UnicodeCol
+from sqlobject.col import validators
+from sqlobject.compat import PY2
+from sqlobject.tests.dbtest import raises, setupClass
+
+if not PY2:
+    # alias for python 3 compatability
+    long = int
+
+########################################
+# Validation/conversion
+########################################
+
+
+class SOTestValidator(validators.Validator):
+    def to_python(self, value, state):
+        if value:
+            self.save_value.append(value)
+            return 1
+        return value
+
+    def from_python(self, value, state):
+        if value:
+            self.save_value.append(value)
+            return 2
+        return value
+
+validator1 = SOTestValidator(save_value=[])
+validator2 = SOTestValidator(save_value=[])
+
+
+class SOValidation(SQLObject):
+
+    name = StringCol(validator=validators.PlainText(),
+                     default='x', dbName='name_col')
+    name2 = StringCol(validator2=validators.ConfirmType(type=str), default='y')
+    name3 = IntCol(validator=validators.Wrapper(fromPython=int), default=100)
+    name4 = FloatCol(default=2.718)
+    name5 = PickleCol(default=None)
+    name6 = BoolCol(default=None)
+    name7 = UnicodeCol(default=None)
+    name8 = IntCol(default=None)
+    name9 = IntCol(validator=validator1, validator2=validator2, default=0)
+
+
+class SOValidationTest(object):
+    def __init__(self, value):
+        self.value = value
+
+
+if PY2:
+    class SOValidationTestUnicode(SOValidationTest):
+        def __unicode__(self):
+            return self.value
+
+
+class SOValidationTestInt(SOValidationTest):
+    def __int__(self):
+        return self.value
+
+
+class SOValidationTestBool(SOValidationTest):
+    def __nonzero__(self):
+        return self.value
+    __bool__ = __nonzero__
+
+
+class SOValidationTestFloat(SOValidationTest):
+    def __float__(self):
+        return self.value
+
+
+class TestValidation:
+
+    def setup_method(self, meth):
+        setupClass(SOValidation)
+
+    def test_validate(self):
+        t = SOValidation(name='hey')
+        raises(validators.Invalid, setattr, t, 'name', '!!!')
+        t.name = 'you'
+        assert t.name == 'you'
+
+    def test_confirmType(self):
+        t = SOValidation(name2='hey')
+        raises(validators.Invalid, setattr, t, 'name2', 1)
+        raises(validators.Invalid, setattr, t, 'name3', '1')
+        raises(validators.Invalid, setattr, t, 'name4', '1')
+        if t._connection.dbName != 'postgres' or \
+                t._connection.driver not in ('odbc', 'pyodbc', 'pypyodbc'):
+            raises(validators.Invalid, setattr, t, 'name6', '1')
+        raises(validators.Invalid, setattr, t, 'name7', 1)
+        t.name2 = 'you'
+        assert t.name2 == 'you'
+
+        for name, cls, value in (
+                ('name4', SOValidationTestFloat, 1.1),
+                ('name6', SOValidationTestBool, True),
+                ('name8', SOValidationTestInt, 1)):
+            setattr(t, name, cls(value))
+            assert getattr(t, name) == value
+        if PY2:
+            for name, cls, value in (
+                    ('name7', SOValidationTestUnicode, u'test'),):
+                setattr(t, name, cls(value))
+                assert getattr(t, name) == value
+
+    def test_wrapType(self):
+        t = SOValidation(name3=1)
+        raises(validators.Invalid, setattr, t, 'name3', 'x')
+        t.name3 = long(1)
+        assert t.name3 == 1
+        t.name3 = 0
+        assert t.name3 == 0
+
+    def test_emptyValue(self):
+        t = SOValidation(name5={})
+        assert t.name5 == {}
+
+    def test_validator2(self):
+        SOValidation(name9=1)
+        SOValidation(name9=2)
+        assert validator1.save_value == [2, 2, 2, 2, 2, 2]
+        assert validator2.save_value == [1, 1, 1, 2, 1, 1]

sqlobject/tests/test_views.py

@@ -0,0 +1,159 @@
+from sqlobject import ForeignKey, IntCol, SQLMultipleJoin, SQLObject, \
+    StringCol, func
+from sqlobject.views import ViewSQLObject
+from sqlobject.tests.dbtest import inserts, setupClass
+
+
+class PhoneNumber(SQLObject):
+    number = StringCol()
+    calls = SQLMultipleJoin('PhoneCall')
+    incoming = SQLMultipleJoin('PhoneCall', joinColumn='toID')
+
+
+class PhoneCall(SQLObject):
+    phoneNumber = ForeignKey('PhoneNumber')
+    to = ForeignKey('PhoneNumber')
+    minutes = IntCol()
+
+
+class ViewPhoneCall(ViewSQLObject):
+    class sqlmeta:
+        idName = PhoneCall.q.id
+        clause = PhoneCall.q.phoneNumberID == PhoneNumber.q.id
+
+    minutes = IntCol(dbName=PhoneCall.q.minutes)
+    number = StringCol(dbName=PhoneNumber.q.number)
+    phoneNumber = ForeignKey('PhoneNumber', dbName=PhoneNumber.q.id)
+    call = ForeignKey('PhoneCall', dbName=PhoneCall.q.id)
+
+
+class ViewPhone(ViewSQLObject):
+    class sqlmeta:
+        idName = PhoneNumber.q.id
+        clause = PhoneCall.q.phoneNumberID == PhoneNumber.q.id
+
+    minutes = IntCol(dbName=func.SUM(PhoneCall.q.minutes))
+    numberOfCalls = IntCol(dbName=func.COUNT(PhoneCall.q.phoneNumberID))
+    number = StringCol(dbName=PhoneNumber.q.number)
+    phoneNumber = ForeignKey('PhoneNumber', dbName=PhoneNumber.q.id)
+    calls = SQLMultipleJoin('PhoneCall', joinColumn='phoneNumberID')
+    vCalls = SQLMultipleJoin('ViewPhoneCall', joinColumn='phoneNumberID',
+                             orderBy='id')
+
+
+class ViewPhoneMore(ViewSQLObject):
+    ''' View on top of view '''
+    class sqlmeta:
+        idName = ViewPhone.q.id
+        clause = ViewPhone.q.id == PhoneCall.q.toID
+
+    number = StringCol(dbName=ViewPhone.q.number)
+    timesCalled = IntCol(dbName=func.COUNT(PhoneCall.q.toID))
+    timesCalledLong = IntCol(dbName=func.COUNT(PhoneCall.q.toID))
+    timesCalledLong.aggregateClause = PhoneCall.q.minutes > 10
+    minutesCalled = IntCol(dbName=func.SUM(PhoneCall.q.minutes))
+
+
+class ViewPhoneMore2(ViewPhoneMore):
+    class sqlmeta:
+        table = 'vpm'
+
+
+class ViewPhoneInnerAggregate(ViewPhone):
+    twiceMinutes = IntCol(dbName=func.SUM(PhoneCall.q.minutes) * 2)
+
+
+def setup_module(mod):
+    global calls, phones, sqlrepr
+    setupClass([PhoneNumber, PhoneCall])
+    ViewPhoneCall._connection = PhoneNumber._connection
+    ViewPhone._connection = PhoneNumber._connection
+    ViewPhoneMore._connection = PhoneNumber._connection
+    phones = inserts(PhoneNumber, [('1234567890',), ('1111111111',)], 'number')
+    calls = inserts(PhoneCall, [(phones[0], phones[1], 5),
+                                (phones[0], phones[1], 20),
+                                (phones[1], phones[0], 10),
+                                (phones[1], phones[0], 25)],
+                    'phoneNumber to minutes')
+    sqlrepr = PhoneNumber._connection.sqlrepr
+
+
+def testSimpleVPC():
+    assert hasattr(ViewPhoneCall, 'minutes')
+    assert hasattr(ViewPhoneCall, 'number')
+    assert hasattr(ViewPhoneCall, 'phoneNumberID')
+
+
+def testColumnSQLVPC():
+    assert str(sqlrepr(ViewPhoneCall.q.id)) == 'view_phone_call.id'
+    assert str(sqlrepr(ViewPhoneCall.q.minutes)) == 'view_phone_call.minutes'
+    q = sqlrepr(ViewPhoneCall.q)
+    assert q.count('phone_call.minutes AS minutes')
+    assert q.count('phone_number.number AS number')
+
+
+def testAliasOverride():
+    assert str(sqlrepr(ViewPhoneMore2.q.id)) == 'vpm.id'
+
+
+def checkAttr(cls, id, attr, value):
+    assert getattr(cls.get(id), attr) == value
+
+
+def testGetVPC():
+    checkAttr(ViewPhoneCall, calls[0].id, 'number',
+              calls[0].phoneNumber.number)
+    checkAttr(ViewPhoneCall, calls[0].id, 'minutes', calls[0].minutes)
+    checkAttr(ViewPhoneCall, calls[0].id, 'phoneNumber', calls[0].phoneNumber)
+    checkAttr(ViewPhoneCall, calls[2].id, 'number',
+              calls[2].phoneNumber.number)
+    checkAttr(ViewPhoneCall, calls[2].id, 'minutes', calls[2].minutes)
+    checkAttr(ViewPhoneCall, calls[2].id, 'phoneNumber', calls[2].phoneNumber)
+
+
+def testGetVP():
+    checkAttr(ViewPhone, phones[0].id, 'number', phones[0].number)
+    checkAttr(ViewPhone, phones[0].id, 'minutes',
+              phones[0].calls.sum(PhoneCall.q.minutes))
+    checkAttr(ViewPhone, phones[0].id, 'phoneNumber', phones[0])
+
+
+def testGetVPM():
+    checkAttr(ViewPhoneMore, phones[0].id, 'number', phones[0].number)
+    checkAttr(ViewPhoneMore, phones[0].id, 'minutesCalled',
+              phones[0].incoming.sum(PhoneCall.q.minutes))
+    checkAttr(ViewPhoneMore, phones[0].id, 'timesCalled',
+              phones[0].incoming.count())
+    checkAttr(ViewPhoneMore, phones[0].id, 'timesCalledLong',
+              phones[0].incoming.filter(PhoneCall.q.minutes > 10).count())
+
+
+def testJoinView():
+    p = ViewPhone.get(phones[0].id)
+    assert p.calls.count() == 2
+    assert p.vCalls.count() == 2
+    assert p.vCalls[0] == ViewPhoneCall.get(calls[0].id)
+
+
+def testInnerAggregate():
+    checkAttr(ViewPhoneInnerAggregate, phones[0].id, 'twiceMinutes',
+              phones[0].calls.sum(PhoneCall.q.minutes) * 2)
+
+
+def testSelect():
+    s = ViewPhone.select()
+    assert s.count() == len(phones)
+    s = ViewPhoneCall.select()
+    assert s.count() == len(calls)
+
+
+def testSelect2():
+    s = ViewPhone.select(ViewPhone.q.number == phones[0].number)
+    assert s.getOne().phoneNumber == phones[0]
+
+
+def testDistinctCount():
+    # This test is for SelectResults non-* based count when distinct
+    # We're really just checking this doesn't raise anything
+    # due to lack of sqlrepr'ing.
+    assert ViewPhone.select(distinct=True).count() == 2

sqlobject/util/__init__.py

@@ -0,0 +1 @@
+#