sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_csvexport.py

@@ -0,0 +1,101 @@
+from __future__ import print_function
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+from sqlobject import IntCol, SQLObject, StringCol
+from sqlobject.util.csvexport import export_csv, export_csv_zip
+from .dbtest import setupClass
+
+
+def assert_export(result, *args, **kw):
+    f = StringIO()
+    kw['writer'] = f
+    export_csv(*args, **kw)
+    s = f.getvalue().replace('\r\n', '\n')
+    if result.strip() != s.strip():
+        print('**Expected:')
+        print(result)
+        print('**Got:')
+        print(s)
+        assert result.strip() == s.strip()
+
+
+class SimpleCSV(SQLObject):
+
+    name = StringCol()
+    address = StringCol()
+    address.csvTitle = 'Street Address'
+    hidden = StringCol()
+    hidden.noCSV = True
+
+
+class ComplexCSV(SQLObject):
+
+    fname = StringCol()
+    lname = StringCol()
+    age = IntCol()
+    extraCSVColumns = [('name', 'Full Name'), 'initials']
+    # initials should end up at the end then:
+    csvColumnOrder = ['name', 'fname', 'lname', 'age']
+
+    def _get_name(self):
+        return self.fname + ' ' + self.lname
+
+    def _get_initials(self):
+        return self.fname[0] + self.lname[0]
+
+
+def test_simple():
+    setupClass(SimpleCSV)
+    SimpleCSV(name='Bob', address='432W', hidden='boo')
+    SimpleCSV(name='Joe', address='123W', hidden='arg')
+    assert_export("""\
+name,Street Address
+Bob,432W
+Joe,123W
+""", SimpleCSV, orderBy='name')
+    assert_export("""\
+name,Street Address
+Joe,123W
+Bob,432W
+""", SimpleCSV, orderBy='address')
+    assert_export("""\
+name,Street Address
+Joe,123W
+""", SimpleCSV.selectBy(name='Joe'))
+
+
+def test_complex():
+    setupClass(ComplexCSV)
+    ComplexCSV(fname='John', lname='Doe', age=40)
+    ComplexCSV(fname='Bob', lname='Dylan', age=60)
+    ComplexCSV(fname='Harriet', lname='Tubman', age=160)
+    assert_export("""\
+Full Name,fname,lname,age,initials
+John Doe,John,Doe,40,JD
+Bob Dylan,Bob,Dylan,60,BD
+Harriet Tubman,Harriet,Tubman,160,HT
+""", ComplexCSV, orderBy='lname')
+    assert_export("""\
+Full Name,fname,lname,age,initials
+Bob Dylan,Bob,Dylan,60,BD
+John Doe,John,Doe,40,JD
+""", ComplexCSV.select(ComplexCSV.q.lname.startswith('D'), orderBy='fname'))
+
+
+def test_zip():
+    # Just exercise tests, doesn't actually test results
+    setupClass(SimpleCSV)
+    SimpleCSV(name='Bob', address='432W', hidden='boo')
+    SimpleCSV(name='Joe', address='123W', hidden='arg')
+
+    setupClass(ComplexCSV)
+    ComplexCSV(fname='John', lname='Doe', age=40)
+    ComplexCSV(fname='Bob', lname='Dylan', age=60)
+    ComplexCSV(fname='Harriet', lname='Tubman', age=160)
+    s = export_csv_zip([SimpleCSV, ComplexCSV])
+    assert isinstance(s, bytes) and s
+    s = export_csv_zip([SimpleCSV.selectBy(name='Bob'),
+                        (ComplexCSV, list(ComplexCSV.selectBy(fname='John')))])

sqlobject/tests/test_csvimport.py

@@ -0,0 +1,21 @@
+import csv
+from datetime import datetime
+from sqlobject.util.csvimport import load_csv
+
+csv_data = """\
+name:str,age:datetime,value:int
+Test,2000-01-01 21:44:33,42"""
+
+
+def test_load_csv():
+    loaded = load_csv(csv.reader(csv_data.split('\n')),
+                      default_class='SQLObject')
+    assert loaded == {
+        'SQLObject': [
+            {
+                'age': datetime(2000, 1, 1, 21, 44, 33),
+                'name': 'Test',
+                'value': 42
+            }
+        ]
+    }

sqlobject/tests/test_cyclic_reference.py

@@ -0,0 +1,55 @@
+import pytest
+from sqlobject import BLOBCol, DateTimeCol, ForeignKey, IntCol, SQLObject, \
+    StringCol, sqlmeta
+from sqlobject.tests.dbtest import getConnection, supports
+
+
+class SOTestCyclicRefA(SQLObject):
+    class sqlmeta(sqlmeta):
+        idName = 'test_id_here'
+        table = 'test_cyclic_ref_a_table'
+    name = StringCol()
+    number = IntCol()
+    so_time = DateTimeCol()
+    short = StringCol(length=10)
+    blobcol = BLOBCol()
+    fkeyb = ForeignKey('SOTestCyclicRefB')
+
+
+class SOTestCyclicRefB(SQLObject):
+    class sqlmeta(sqlmeta):
+        idName = 'test_id_here'
+        table = 'test_cyclic_ref_b_table'
+    name = StringCol()
+    number = IntCol()
+    so_time = DateTimeCol()
+    short = StringCol(length=10)
+    blobcol = BLOBCol()
+    fkeya = ForeignKey('SOTestCyclicRefA')
+
+
+def test_cyclic_reference():
+    if not supports('dropTableCascade'):
+        pytest.skip("dropTableCascade isn't supported")
+    conn = getConnection()
+    SOTestCyclicRefA.setConnection(conn)
+    SOTestCyclicRefB.setConnection(conn)
+    SOTestCyclicRefA.dropTable(ifExists=True, cascade=True)
+    assert not conn.tableExists(SOTestCyclicRefA.sqlmeta.table)
+    SOTestCyclicRefB.dropTable(ifExists=True, cascade=True)
+    assert not conn.tableExists(SOTestCyclicRefB.sqlmeta.table)
+
+    constraints = SOTestCyclicRefA.createTable(ifNotExists=True,
+                                               applyConstraints=False)
+    assert conn.tableExists(SOTestCyclicRefA.sqlmeta.table)
+    constraints += SOTestCyclicRefB.createTable(ifNotExists=True,
+                                                applyConstraints=False)
+    assert conn.tableExists(SOTestCyclicRefB.sqlmeta.table)
+
+    for constraint in constraints:
+        conn.query(constraint)
+
+    SOTestCyclicRefA.dropTable(ifExists=True, cascade=True)
+    assert not conn.tableExists(SOTestCyclicRefA.sqlmeta.table)
+    SOTestCyclicRefB.dropTable(ifExists=True, cascade=True)
+    assert not conn.tableExists(SOTestCyclicRefB.sqlmeta.table)

sqlobject/tests/test_datetime.py

@@ -0,0 +1,171 @@
+from datetime import datetime, date, time
+import pytest
+
+from sqlobject import SQLObject
+from sqlobject import col
+from sqlobject.col import DateCol, DateTimeCol, TimeCol, use_microseconds, \
+    DATETIME_IMPLEMENTATION, MXDATETIME_IMPLEMENTATION, mxdatetime_available, \
+    ZOPE_DATETIME_IMPLEMENTATION, zope_datetime_available
+from sqlobject.tests.dbtest import getConnection, setupClass
+from sqlobject.converters import pendulumDateTimeType
+
+########################################
+# Date/time columns
+########################################
+
+
+col.default_datetime_implementation = DATETIME_IMPLEMENTATION
+
+
+class DateTime1(SQLObject):
+    col1 = DateTimeCol()
+    col2 = DateCol()
+    col3 = TimeCol()
+
+
+def test_dateTime():
+    setupClass(DateTime1)
+    _now = datetime.now().replace(microsecond=0)
+    dt1 = DateTime1(col1=_now, col2=_now, col3=_now.time())
+
+    assert isinstance(dt1.col1, datetime)
+    assert dt1.col1.year == _now.year
+    assert dt1.col1.month == _now.month
+    assert dt1.col1.day == _now.day
+    assert dt1.col1.hour == _now.hour
+    assert dt1.col1.minute == _now.minute
+    assert dt1.col1.second == _now.second
+
+    assert isinstance(dt1.col2, date)
+    assert not isinstance(dt1.col2, datetime)
+    assert dt1.col2.year == _now.year
+    assert dt1.col2.month == _now.month
+    assert dt1.col2.day == _now.day
+
+    assert isinstance(dt1.col3, time)
+    assert dt1.col3.hour == _now.hour
+    assert dt1.col3.minute == _now.minute
+    assert dt1.col3.second == _now.second
+
+
+def test_microseconds():
+    connection = getConnection()
+    if not hasattr(connection, 'can_use_microseconds') or \
+            not connection.can_use_microseconds():
+        pytest.skip(
+            "The database doesn't support microseconds; "
+            "microseconds are supported by MariaDB since version 5.3.0, "
+            "by MySQL since version 5.6.4, "
+            "by MSSQL since MS SQL Server 2008.")
+
+    setupClass(DateTime1)
+    _now = datetime.now()
+    dt1 = DateTime1(col1=_now, col2=_now, col3=_now.time())
+
+    assert dt1.col1.microsecond == _now.microsecond
+    assert dt1.col3.microsecond == _now.microsecond
+
+    use_microseconds(False)
+    setupClass(DateTime1)
+    _now = datetime.now()
+    dt1 = DateTime1(col1=_now, col2=_now, col3=_now.time())
+
+    assert dt1.col1.microsecond == 0
+    assert dt1.col3.microsecond == 0
+
+    use_microseconds(True)
+    setupClass(DateTime1)
+    _now = datetime.now()
+    dt1 = DateTime1(col1=_now, col2=_now, col3=_now.time())
+
+    assert dt1.col1.microsecond == _now.microsecond
+    assert dt1.col3.microsecond == _now.microsecond
+
+if mxdatetime_available:
+    col.default_datetime_implementation = MXDATETIME_IMPLEMENTATION
+    from mx.DateTime import now as mx_now, Time as mxTime
+
+    dateFormat = None  # use default
+    try:
+        connection = getConnection()
+    except AttributeError:
+        # The module was imported during documentation building
+        pass
+    else:
+        if connection.dbName == "sqlite":
+            # mxDateTime sends and sqlite3 returns
+            # full date/time for dates
+            dateFormat = "%Y-%m-%d %H:%M:%S.%f"
+
+    class DateTime2(SQLObject):
+        col1 = DateTimeCol()
+        col2 = DateCol(dateFormat=dateFormat)
+        col3 = TimeCol()
+
+    def test_mxDateTime():
+        setupClass(DateTime2)
+        _now = mx_now()
+        dt2 = DateTime2(col1=_now, col2=_now.pydate(),
+                        col3=mxTime(_now.hour, _now.minute, _now.second))
+
+        assert isinstance(dt2.col1, col.mxDateTimeType)
+        assert dt2.col1.year == _now.year
+        assert dt2.col1.month == _now.month
+        assert dt2.col1.day == _now.day
+        assert dt2.col1.hour == _now.hour
+        assert dt2.col1.minute == _now.minute
+        assert dt2.col1.second == int(_now.second)
+
+        assert isinstance(dt2.col2, col.mxDateTimeType)
+        assert dt2.col2.year == _now.year
+        assert dt2.col2.month == _now.month
+        assert dt2.col2.day == _now.day
+        assert dt2.col2.hour == 0
+        assert dt2.col2.minute == 0
+        assert dt2.col2.second == 0
+
+        assert isinstance(dt2.col3, (col.mxDateTimeType, col.mxTimeType))
+        assert dt2.col3.hour == _now.hour
+        assert dt2.col3.minute == _now.minute
+        assert dt2.col3.second == int(_now.second)
+
+if pendulumDateTimeType:
+    col.default_datetime_implementation = DATETIME_IMPLEMENTATION
+    import pendulum
+
+    class DateTimePendulum(SQLObject):
+        col1 = DateTimeCol()
+
+    def test_PendulumDateTime():
+        setupClass(DateTimePendulum)
+        _now = pendulum.now()
+        dtp = DateTimePendulum(col1=_now)
+
+        assert isinstance(dtp.col1, datetime)
+        assert dtp.col1.year == _now.year
+        assert dtp.col1.month == _now.month
+        assert dtp.col1.day == _now.day
+        assert dtp.col1.hour == _now.hour
+        assert dtp.col1.minute == _now.minute
+        assert int(dtp.col1.second) == int(_now.second)
+
+
+if zope_datetime_available:
+    col.default_datetime_implementation = ZOPE_DATETIME_IMPLEMENTATION
+    from DateTime import DateTime as zopeDateTime
+
+    class DateTime3(SQLObject):
+        col1 = DateTimeCol()
+
+    def test_ZopeDateTime():
+        setupClass(DateTime3)
+        _now = zopeDateTime()
+        dt3 = DateTime3(col1=_now)
+
+        assert isinstance(dt3.col1, col.zopeDateTimeType)
+        assert dt3.col1.year() == _now.year()
+        assert dt3.col1.month() == _now.month()
+        assert dt3.col1.day() == _now.day()
+        assert dt3.col1.hour() == _now.hour()
+        assert dt3.col1.minute() == _now.minute()
+        assert int(dt3.col1.second()) == int(_now.second())

sqlobject/tests/test_dbconnection.py

@@ -0,0 +1,17 @@
+from pytest import raises
+from sqlobject.dbconnection import DBConnection
+
+
+def test_name():
+    connection = DBConnection(name='test')
+    connection.close = lambda: True
+
+    with raises(AssertionError) as error:
+        DBConnection(name='test')
+    assert str(error.value) == 'An instance has already been registered ' \
+        'with the name test'
+
+    with raises(AssertionError) as error:
+        DBConnection(name='test:test')
+    assert str(error.value) == "You cannot include ':' " \
+        "in your DB connection names ('test:test')"

sqlobject/tests/test_decimal.py

@@ -0,0 +1,63 @@
+from decimal import Decimal
+import pytest
+from sqlobject import DecimalCol, DecimalStringCol, SQLObject, UnicodeCol
+from sqlobject.tests.dbtest import setupClass, supports
+
+
+########################################
+# Decimal columns
+########################################
+
+
+try:
+    support_decimal_column = supports('decimalColumn')
+except NameError:
+    # The module was imported during documentation building
+    pass
+else:
+    if not support_decimal_column:
+        pytestmark = pytest.mark.skip("These tests require Decimal support")
+
+
+class DecimalTable(SQLObject):
+    name = UnicodeCol(length=255)
+    col1 = DecimalCol(size=6, precision=4)
+    col2 = DecimalStringCol(size=6, precision=4)
+    col3 = DecimalStringCol(size=6, precision=4, quantize=True)
+
+
+def test_1_decimal():
+    setupClass(DecimalTable)
+    d = DecimalTable(name='test', col1=21.12, col2='10.01', col3='10.01')
+    # psycopg2 returns float as Decimal
+    if isinstance(d.col1, Decimal):
+        assert d.col1 == Decimal("21.12")
+    else:
+        assert d.col1 == 21.12
+    assert d.col2 == Decimal("10.01")
+    assert DecimalTable.sqlmeta.columns['col2'].to_python(
+        '10.01', d._SO_validatorState) == Decimal("10.01")
+    assert DecimalTable.sqlmeta.columns['col2'].from_python(
+        '10.01', d._SO_validatorState) == "10.01"
+    assert d.col3 == Decimal("10.01")
+    assert DecimalTable.sqlmeta.columns['col3'].to_python(
+        '10.01', d._SO_validatorState) == Decimal("10.01")
+    assert DecimalTable.sqlmeta.columns['col3'].from_python(
+        '10.01', d._SO_validatorState) == "10.0100"
+
+
+def test_2_decimal():
+    setupClass(DecimalTable)
+    d = DecimalTable(name='test', col1=Decimal("21.12"),
+                     col2=Decimal('10.01'), col3=Decimal('10.01'))
+    assert d.col1 == Decimal("21.12")
+    assert d.col2 == Decimal("10.01")
+    assert DecimalTable.sqlmeta.columns['col2'].to_python(
+        Decimal('10.01'), d._SO_validatorState) == Decimal("10.01")
+    assert DecimalTable.sqlmeta.columns['col2'].from_python(
+        Decimal('10.01'), d._SO_validatorState) == "10.01"
+    assert d.col3 == Decimal("10.01")
+    assert DecimalTable.sqlmeta.columns['col3'].to_python(
+        Decimal('10.01'), d._SO_validatorState) == Decimal("10.01")
+    assert DecimalTable.sqlmeta.columns['col3'].from_python(
+        Decimal('10.01'), d._SO_validatorState) == "10.0100"

sqlobject/tests/test_declarative.py

@@ -0,0 +1,83 @@
+from sqlobject.declarative import Declarative
+
+
+class A1(Declarative):
+
+    a = 1
+    b = []
+
+
+class A2(A1):
+
+    a = 5
+
+A3 = A2(b=5)
+
+
+def test_a_classes():
+    assert A1.a == 1
+    assert A1.singleton().a == 1
+    assert A1.b is A2.b
+    assert A3.b == 5
+    assert A1.declarative_count == A1.singleton().declarative_count
+    assert A1.declarative_count < A2.declarative_count
+    assert A2.singleton() is not A1.singleton()
+    assert A3.singleton().b == A3.b
+
+
+class B1(Declarative):
+
+    attrs = []
+
+    def __classinit__(cls, new_attrs):
+        Declarative.__classinit__(cls, new_attrs)
+        cls.attrs = cls.add_attrs(cls.attrs, new_attrs)
+
+    def __instanceinit__(self, new_attrs):
+        Declarative.__instanceinit__(self, new_attrs)
+        self.attrs = self.add_attrs(self.attrs, new_attrs)
+
+    @staticmethod
+    def add_attrs(old_attrs, new_attrs):
+        old_attrs = old_attrs[:]
+        for name in new_attrs.keys():
+            if (name in old_attrs or name.startswith('_')
+                    or name in ('add_attrs', 'declarative_count', 'attrs')):
+                continue
+            old_attrs.append(name)
+        old_attrs.sort()
+        return old_attrs
+
+    c = 1
+
+
+class B2(B1):
+
+    g = 3
+
+    def __classinit__(cls, new_attrs):
+        new_attrs['test'] = 'whatever'
+        B1.__classinit__(cls, new_attrs)
+
+B3 = B2(c=5, d=3)
+B4 = B3(d=5)
+B5 = B1(a=1)
+
+
+def test_b_classes():
+    assert B1.attrs == ['c']
+    assert B1.c == 1
+    assert B2.attrs == ['c', 'g', 'test']
+    assert B3.d == 3
+    assert B4.d == 5
+    assert B5.a == 1
+    assert B5.attrs == ['a', 'c']
+    assert B3.attrs == ['c', 'd', 'g', 'test']
+    assert B4.attrs == ['c', 'd', 'g', 'test']
+    order = [B1, B1.singleton(), B2, B2.singleton(),
+             B3, B3.singleton(), B4, B4.singleton(),
+             B5, B5.singleton()]
+    last = 0
+    for obj in order:
+        assert obj.declarative_count >= last
+        last = obj.declarative_count

sqlobject/tests/test_default_style.py

@@ -0,0 +1,65 @@
+"""
+Test the default styles, to guarantee consistency.
+"""
+
+from sqlobject import ForeignKey, MixedCaseStyle, MixedCaseUnderscoreStyle, \
+    SQLObject, StringCol, Style
+
+# Hash of styles versus the database names resulting from 'columns' below.
+columns = ["ABCUpper", "abc_lower", "ABCamelCaseColumn"]
+styles = {
+    Style: columns,
+    MixedCaseUnderscoreStyle: ["abc_upper", "abc_lower",
+                               "ab_camel_case_column"],
+    MixedCaseStyle: ["ABCUpper", "Abc_lower", "ABCamelCaseColumn"],
+}
+
+# Hash of styles versus the database names
+# resulting from a foreign key named 'FKey'.
+fkey = ForeignKey("DefaultStyleTest", name="FKey")
+fkeys = {
+    Style: "FKeyID",
+    MixedCaseUnderscoreStyle: "f_key_id",
+    MixedCaseStyle: "FKeyID",
+}
+
+
+def make_columns():
+    global columns
+    columns = []
+    for col_name in columns:
+        columns.append(StringCol(name=col_name, length=10))
+
+
+def do_col_test(DefaultStyleTest, style, dbnames):
+    DefaultStyleTest.sqlmeta.style = style()
+    for col, old_dbname in zip(columns, dbnames):
+        DefaultStyleTest.sqlmeta.addColumn(col)
+        try:
+            new_dbname = DefaultStyleTest.sqlmeta.columns[col.name].dbName
+            assert new_dbname == old_dbname
+        finally:
+            if col.name in DefaultStyleTest.sqlmeta.columns:
+                DefaultStyleTest.sqlmeta.delColumn(col)
+
+
+def do_fkey_test(DefaultStyleTest, style, dbname):
+    DefaultStyleTest.sqlmeta.style = style()
+    DefaultStyleTest.sqlmeta.addColumn(fkey)
+    try:
+        assert list(DefaultStyleTest.sqlmeta.columns.keys())[0] == "FKeyID"
+        assert list(DefaultStyleTest.sqlmeta.columns.values())[0].dbName == \
+            dbname
+    finally:
+        DefaultStyleTest.sqlmeta.delColumn(fkey)
+
+
+class DefaultStyleTest(SQLObject):
+    pass
+
+
+def test_default_styles():
+    make_columns()
+    for style in styles:
+        do_col_test(DefaultStyleTest, style, styles[style])
+        do_fkey_test(DefaultStyleTest, style, fkeys[style])

sqlobject/tests/test_delete.py

@@ -0,0 +1,74 @@
+from sqlobject import OR, RelatedJoin, SQLObject, StringCol, cache
+from sqlobject.tests.dbtest import setupClass
+from .test_basic import SOTestSO1, setupGetters
+
+
+########################################
+# Delete during select
+########################################
+
+
+def testSelect():
+    setupGetters(SOTestSO1)
+    for obj in SOTestSO1.select('all'):
+        obj.destroySelf()
+    assert list(SOTestSO1.select('all')) == []
+
+
+########################################
+# Delete many rows at once
+########################################
+
+
+def testDeleteMany():
+    setupGetters(SOTestSO1)
+    SOTestSO1.deleteMany(OR(SOTestSO1.q.name == "bob",
+                            SOTestSO1.q.name == "fred"))
+    assert len(list(SOTestSO1.select('all'))) == 2
+
+
+def testDeleteBy():
+    setupGetters(SOTestSO1)
+    SOTestSO1.deleteBy(name="dave")
+    assert len(list(SOTestSO1.select())) == 3
+
+
+########################################
+# Delete without caching
+########################################
+
+
+class NoCache(SQLObject):
+    name = StringCol()
+
+
+def testDestroySelf():
+    setupClass(NoCache)
+    old = NoCache._connection.cache
+    NoCache._connection.cache = cache.CacheSet(cache=False)
+    value = NoCache(name='test')
+    value.destroySelf()
+    NoCache._connection.cache = old
+
+
+########################################
+# Delete from related joins
+########################################
+
+
+class Service(SQLObject):
+    groups = RelatedJoin("ServiceGroup")
+
+
+class ServiceGroup(SQLObject):
+    services = RelatedJoin("Service")
+
+
+def testDeleteRelatedJoins():
+    setupClass([Service, ServiceGroup])
+    service = Service()
+    service_group = ServiceGroup()
+    service.addServiceGroup(service_group)
+    service.destroySelf()
+    service_group = ServiceGroup.get(service_group.id)
+    assert len(service_group.services) == 0

sqlobject/tests/test_distinct.py

@@ -0,0 +1,36 @@
+from sqlobject import ForeignKey, IntCol, SQLObject
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Distinct
+########################################
+
+
+class Distinct1(SQLObject):
+    n = IntCol()
+
+
+class Distinct2(SQLObject):
+    other = ForeignKey('Distinct1')
+
+
+def count(select):
+    result = {}
+    for ob in select:
+        result[int(ob.n)] = result.get(int(ob.n), 0) + 1
+    return result
+
+
+def test_distinct():
+    setupClass([Distinct1, Distinct2])
+    obs = [Distinct1(n=i) for i in range(3)]
+    Distinct2(other=obs[0])
+    Distinct2(other=obs[0])
+    Distinct2(other=obs[1])
+
+    query = (Distinct2.q.otherID == Distinct1.q.id)
+    sel = Distinct1.select(query)
+    assert count(sel) == {0: 2, 1: 1}
+    sel = Distinct1.select(query, distinct=True)
+    assert count(sel) == {0: 1, 1: 1}