sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_cache.py

@@ -0,0 +1,57 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.cache import CacheSet
+from .dbtest import setupClass
+
+
+class Something(object):
+    pass
+
+
+def test_purge1():
+    x = CacheSet()
+    y = Something()
+    obj = x.get(1, y.__class__)
+    assert obj is None
+    x.put(1, y.__class__, y)
+    x.finishPut(y.__class__)
+    j = x.get(1, y.__class__)
+    assert j == y
+    x.expire(1, y.__class__)
+    j = x.get(1, y.__class__)
+    assert j is None
+    x.finishPut(y.__class__)
+    j = x.get(1, y.__class__)
+    assert j is None
+    x.finishPut(y.__class__)
+
+
+class CacheTest(SQLObject):
+    name = StringCol(alternateID=True, length=100)
+
+
+def test_cache():
+    setupClass(CacheTest)
+    s = CacheTest(name='foo')
+    obj_id = id(s)
+    s_id = s.id
+    assert CacheTest.get(s_id) is s
+    assert not s.sqlmeta.expired
+    CacheTest.sqlmeta.expireAll()
+    assert s.sqlmeta.expired
+    CacheTest.sqlmeta.expireAll()
+    s1 = CacheTest.get(s_id)
+    # We should have a new object:
+    assert id(s1) != obj_id
+    obj_id2 = id(s1)
+    CacheTest._connection.expireAll()
+    s2 = CacheTest.get(s_id)
+    assert id(s2) != obj_id and id(s2) != obj_id2
+
+
+def test_cache_cull():
+    setupClass(CacheTest)
+    s = CacheTest(name='test_cache_create')
+    for count in range(s._connection.cache.caches['CacheTest'].cullFrequency):
+        CacheTest(name='test_cache_create %d' % count)
+    assert len(s._connection.cache.caches['CacheTest'].cache) < \
+        s._connection.cache.caches['CacheTest'].cullFrequency

sqlobject/tests/test_class_hash.py

@@ -0,0 +1,22 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Test hashing a column instance
+########################################
+
+
+class ClassHashTest(SQLObject):
+    name = StringCol(length=50, alternateID=True, dbName='name_col')
+
+
+def test_class_hash():
+    setupClass(ClassHashTest)
+    ClassHashTest(name='bob')
+
+    b = ClassHashTest.byName('bob')
+    hashed = hash(b)
+    b.expire()
+    b = ClassHashTest.byName('bob')
+    assert hash(b) == hashed

sqlobject/tests/test_columns_order.py

@@ -0,0 +1,18 @@
+from sqlobject import IntCol, SQLObject, StringCol
+
+
+########################################
+# Columns order
+########################################
+
+
+class SOColumnsOrder(SQLObject):
+    name = StringCol()
+    surname = StringCol()
+    parname = StringCol()
+    age = IntCol()
+
+
+def test_columns_order():
+    column_names = [c.name for c in SOColumnsOrder.sqlmeta.columnList]
+    assert column_names == ['name', 'surname', 'parname', 'age']

sqlobject/tests/test_combining_joins.py

@@ -0,0 +1,47 @@
+from sqlobject import ForeignKey, ManyToMany, OneToMany, SQLObject, StringCol
+from .dbtest import setupClass
+
+
+class ComplexGroup(SQLObject):
+    name = StringCol()
+    complexes = OneToMany('Complex')
+
+    def _get_unit_models(self):
+        q = self.complexes.clause & Complex.unit_models.clause
+        return UnitModel.select(q)
+
+
+class Complex(SQLObject):
+    name = StringCol()
+    unit_models = ManyToMany('UnitModel')
+    complex_group = ForeignKey('ComplexGroup')
+
+
+class UnitModel(SQLObject):
+    class sqlmeta:
+        defaultOrderBy = 'name'
+    name = StringCol()
+    complexes = ManyToMany('Complex')
+
+
+def test_join_sqlrepr():
+    setupClass([ComplexGroup, UnitModel, Complex])
+    cg1 = ComplexGroup(name='cg1')
+    cg2 = ComplexGroup(name='cg2')
+    c1 = Complex(name='c1', complex_group=cg1)
+    c2 = Complex(name='c2', complex_group=cg2)
+    c3 = Complex(name='c3', complex_group=cg2)
+    u1 = UnitModel(name='u1')
+    u2 = UnitModel(name='u2')
+    u1.complexes.add(c1)
+    u1.complexes.add(c2)
+    u2.complexes.add(c2)
+    u2.complexes.add(c3)
+    assert list(Complex.selectBy(name='c1')) == [c1]
+
+    assert list(cg1.unit_models) == [u1]
+    assert list(cg2.unit_models) == [u1, u2, u2]
+    assert list(cg2.unit_models.distinct()) == [u1, u2]
+
+    assert list(
+        cg2.unit_models.filter(UnitModel.q.name == 'u1')) == [u1]

sqlobject/tests/test_comparison.py

@@ -0,0 +1,24 @@
+from sqlobject import SQLObject
+from sqlobject.tests.dbtest import setupClass
+
+
+class SOTestComparison(SQLObject):
+    pass
+
+
+def test_eq():
+    setupClass(SOTestComparison, force=True)
+    t1 = SOTestComparison()
+    t2 = SOTestComparison()
+
+    SOTestComparison._connection.cache.clear()
+    t3 = SOTestComparison.get(1)
+    t4 = SOTestComparison.get(2)
+
+    assert t1.id == t3.id
+    assert t2.id == t4.id
+    assert t1 is not t3
+    assert t2 is not t4
+    assert t1 == t3
+    assert t2 == t4
+    assert t1 != t2

sqlobject/tests/test_compat.py

@@ -0,0 +1,10 @@
+from sqlobject.compat import load_module_from_file
+
+
+def test_load_module_from_path():
+    module = load_module_from_file(
+        'test_compat', 'sqlobject.tests.test_compat', __file__
+    )
+    assert module.__file__ == __file__
+    assert module.__name__ == 'sqlobject.tests.test_compat'
+    assert module.__package__ == 'sqlobject.tests'

sqlobject/tests/test_complex_sorting.py

@@ -0,0 +1,77 @@
+from sqlobject import IntCol, SQLObject, StringCol, sqlmeta
+from sqlobject.tests.dbtest import inserts, setupClass
+
+# Test more complex orderBy clauses
+
+
+class ComplexNames(SQLObject):
+
+    class sqlmeta(sqlmeta):
+        table = 'names_table'
+        defaultOrder = ['lastName', 'firstName', 'phone', 'age']
+
+    firstName = StringCol(length=30)
+    lastName = StringCol(length=30)
+    phone = StringCol(length=11)
+    age = IntCol()
+
+
+def setupComplexNames():
+    setupClass(ComplexNames)
+    inserts(ComplexNames, [('aj', 'baker', '555-444-333', 34),
+                           ('joe', 'robbins', '444-555-333', 34),
+                           ('tim', 'jackson', '555-444-222', 32),
+                           ('joe', 'baker', '222-111-000', 24),
+                           ('zoe', 'robbins', '444-555-333', 46)],
+            schema='firstName lastName phone age')
+
+
+def nameList(names):
+    result = []
+    for name in names:
+        result.append('%s %s' % (name.firstName, name.lastName))
+    return result
+
+
+def firstList(names):
+    return [n.firstName for n in names]
+
+
+def test_defaultComplexOrder():
+    setupComplexNames()
+    assert nameList(ComplexNames.select()) == \
+        ['aj baker', 'joe baker',
+         'tim jackson', 'joe robbins',
+         'zoe robbins']
+
+
+def test_complexOrders():
+    setupComplexNames()
+    assert nameList(ComplexNames.select().orderBy(['age', 'phone',
+                                                   'firstName',
+                                                   'lastName'])) == \
+        ['joe baker', 'tim jackson',
+         'joe robbins', 'aj baker',
+         'zoe robbins']
+    assert nameList(ComplexNames.select().orderBy(['-age', 'phone',
+                                                   'firstName',
+                                                   'lastName'])) == \
+        ['zoe robbins', 'joe robbins',
+         'aj baker', 'tim jackson',
+         'joe baker']
+    assert nameList(ComplexNames.select().orderBy(['age', '-phone',
+                                                   'firstName',
+                                                   'lastName'])) == \
+        ['joe baker', 'tim jackson',
+         'aj baker', 'joe robbins',
+         'zoe robbins']
+    assert nameList(ComplexNames.select().orderBy(['-firstName', 'phone',
+                                                   'lastName', 'age'])) == \
+        ['zoe robbins', 'tim jackson',
+         'joe baker', 'joe robbins',
+         'aj baker']
+    assert nameList(ComplexNames.select().orderBy(['-firstName', '-phone',
+                                                   'lastName', 'age'])) == \
+        ['zoe robbins', 'tim jackson',
+         'joe robbins', 'joe baker',
+         'aj baker']

sqlobject/tests/test_constraints.py

@@ -0,0 +1,43 @@
+from sqlobject.compat import PY2
+from sqlobject.constraints import BadValue, InList, MaxLength, \
+    isFloat, isInt, isString, notNull
+from sqlobject.tests.dbtest import Dummy, raises
+
+if not PY2:
+    # alias for python 3 compatability
+    long = int
+
+
+def test_constraints():
+    obj = 'Test object'
+    col = Dummy(name='col')
+    isString(obj, col, 'blah')
+    raises(BadValue, isString, obj, col, 1)
+    if PY2:
+        # @@: Should this really be an error?
+        raises(BadValue, isString, obj, col, u'test!')
+    else:
+        raises(BadValue, isString, obj, col, b'test!')
+    # isString(obj, col, u'test!')
+
+    raises(BadValue, notNull, obj, col, None)
+    raises(BadValue, isInt, obj, col, 1.1)
+    isInt(obj, col, 1)
+    isInt(obj, col, long(1))
+    isFloat(obj, col, 1)
+    isFloat(obj, col, long(1))
+    isFloat(obj, col, 1.2)
+    raises(BadValue, isFloat, obj, col, '1.0')
+
+    # @@: Should test isBool, but I don't think isBool is right
+
+    lst = InList(('a', 'b', 'c'))
+    lst(obj, col, 'a')
+    raises(BadValue, lst, obj, col, ('a', 'b', 'c'))
+    raises(BadValue, lst, obj, col, 'A')
+
+    maxlen = MaxLength(2)
+    raises(BadValue, maxlen, obj, col, '123')
+    maxlen(obj, col, '12')
+    maxlen(obj, col, (1,))
+    raises(BadValue, maxlen, obj, col, 1)

sqlobject/tests/test_converters.py

@@ -0,0 +1,276 @@
+from datetime import timedelta
+
+from sqlobject.col import SODateTimeCol, SOTimeCol
+from sqlobject.converters import registerConverter, sqlrepr, \
+    quote_str, unquote_str
+from sqlobject.sqlbuilder import SQLExpression, SQLObjectField, \
+    Select, Insert, Update, Delete, Replace, \
+    SQLTrueClauseClass, SQLConstant, SQLPrefix, SQLCall, SQLOp, \
+    _LikeQuoted
+
+
+class SOTestClass:
+
+    def __repr__(self):
+        return '<SOTestClass>'
+
+
+def SOTestClassConverter(value, db):
+    return repr(value)
+
+registerConverter(SOTestClass, SOTestClassConverter)
+
+
+class NewSOTestClass:
+
+    __metaclass__ = type
+
+    def __repr__(self):
+        return '<NewSOTestClass>'
+
+
+def NewSOTestClassConverter(value, db):
+    return repr(value)
+
+registerConverter(NewSOTestClass, NewSOTestClassConverter)
+
+
+def _sqlrepr(self, db):
+    return '<%s>' % self.__class__.__name__
+
+SQLExpression.__sqlrepr__ = _sqlrepr
+
+############################################################
+# Tests
+############################################################
+
+
+def test_simple_string():
+    assert sqlrepr('A String', 'firebird') == "'A String'"
+
+
+def test_string_newline():
+    assert sqlrepr('A String\nAnother', 'postgres') == "E'A String\\nAnother'"
+    assert sqlrepr('A String\nAnother', 'sqlite') == "'A String\nAnother'"
+
+
+def test_string_tab():
+    assert sqlrepr('A String\tAnother', 'postgres') == "E'A String\\tAnother'"
+
+
+def test_string_r():
+    assert sqlrepr('A String\rAnother', 'postgres') == "E'A String\\rAnother'"
+
+
+def test_string_b():
+    assert sqlrepr('A String\bAnother', 'postgres') == "E'A String\\bAnother'"
+
+
+def test_string_000():
+    assert sqlrepr('A String\000Another', 'postgres') == \
+        "E'A String\\0Another'"
+
+
+def test_string_():
+    assert sqlrepr('A String\tAnother', 'postgres') == "E'A String\\tAnother'"
+    assert sqlrepr('A String\'Another', 'firebird') == "'A String''Another'"
+
+
+def test_simple_unicode():
+    assert sqlrepr(u'A String', 'postgres') == "'A String'"
+
+
+def test_integer():
+    assert sqlrepr(10) == "10"
+
+
+def test_float():
+    assert sqlrepr(10.01) == "10.01"
+
+
+def test_none():
+    assert sqlrepr(None) == "NULL"
+
+
+def test_list():
+    assert sqlrepr(['one', 'two', 'three'], 'postgres') == \
+        "('one', 'two', 'three')"
+
+
+def test_tuple():
+    assert sqlrepr(('one', 'two', 'three'), 'postgres') == \
+        "('one', 'two', 'three')"
+
+
+def test_bool():
+    assert sqlrepr(True, 'postgres') == "'t'"
+    assert sqlrepr(False, 'postgres') == "'f'"
+    assert sqlrepr(True, 'mysql') == "1"
+    assert sqlrepr(False, 'mysql') == "0"
+
+
+def test_datetime():
+    from datetime import datetime, date, time
+    if SODateTimeCol.datetimeFormat.find('.%f') > 0:
+        assert sqlrepr(datetime(2005, 7, 14, 13, 31, 2)) == \
+            "'2005-07-14 13:31:02.000000'"
+    else:
+        assert sqlrepr(datetime(2005, 7, 14, 13, 31, 2)) == \
+            "'2005-07-14 13:31:02'"
+    assert sqlrepr(date(2005, 7, 14)) == "'2005-07-14'"
+    if SOTimeCol.timeFormat.find('.%f') > 0:
+        assert sqlrepr(time(13, 31, 2)) == "'13:31:02.000000'"
+    else:
+        assert sqlrepr(time(13, 31, 2)) == "'13:31:02'"
+    # now dates before 1900
+    if SODateTimeCol.datetimeFormat.find('.%f') > 0:
+        assert sqlrepr(datetime(1428, 7, 14, 13, 31, 2)) == \
+            "'1428-07-14 13:31:02.000000'"
+    else:
+        assert sqlrepr(datetime(1428, 7, 14, 13, 31, 2)) == \
+            "'1428-07-14 13:31:02'"
+    assert sqlrepr(date(1428, 7, 14)) == "'1428-07-14'"
+
+
+def test_instance():
+    instance = SOTestClass()
+    assert sqlrepr(instance) == repr(instance)
+
+
+def test_newstyle():
+    instance = NewSOTestClass()
+    assert sqlrepr(instance) == repr(instance)
+
+
+def test_sqlexpr():
+    instance = SQLExpression()
+    assert sqlrepr(instance) == repr(instance)
+
+
+def test_sqlobjectfield():
+    instance = SQLObjectField('test', 'test', 'test', None, None)
+    assert sqlrepr(instance) == repr(instance)
+
+
+def test_select():
+    instance = Select('test')
+    assert sqlrepr(instance, 'mysql') == "SELECT test"
+
+
+def test_insert():
+    # Single column, no keyword arguments.
+    instance = Insert('test', [('test',)])
+    assert sqlrepr(instance, 'mysql') == "INSERT INTO test VALUES ('test')"
+
+    # Multiple columns, no keyword arguments.
+    instance2 = Insert('test', [('1st', '2nd', '3th', '4th')])
+    assert sqlrepr(instance2, 'postgres') == \
+        "INSERT INTO test VALUES ('1st', '2nd', '3th', '4th')"
+
+    # Multiple rows, multiple columns, "valueList" keyword argument.
+    instance3 = Insert('test',
+                       valueList=[('a1', 'b1'), ('a2', 'b2'), ('a3', 'b3')])
+    assert sqlrepr(instance3, 'sqlite') == \
+        "INSERT INTO test VALUES ('a1', 'b1'), ('a2', 'b2'), ('a3', 'b3')"
+
+    # Multiple columns, "values" keyword argument.
+    instance4 = Insert('test', values=('v1', 'v2', 'v3'))
+    assert sqlrepr(instance4, 'mysql') == \
+        "INSERT INTO test VALUES ('v1', 'v2', 'v3')"
+
+    # Single column, "valueList" keyword argument.
+    instance5 = Insert('test', valueList=[('v1',)])
+    assert sqlrepr(instance5, 'mysql') == "INSERT INTO test VALUES ('v1')"
+
+    # Multiple rows, Multiple columns, template.
+    instance6 = Insert('test',
+                       valueList=[('a1', 'b1'), ('a2', 'b2')],
+                       template=['col1', 'col2'])
+    assert sqlrepr(instance6, 'mysql') == \
+        "INSERT INTO test (col1, col2) VALUES ('a1', 'b1'), ('a2', 'b2')"
+
+    # Multiple columns, implicit template (dictionary value).
+    instance7 = Insert('test', valueList=[{'col1': 'a1', 'col2': 'b1'}])
+    assert sqlrepr(instance7, 'mysql') == \
+        "INSERT INTO test (col1, col2) VALUES ('a1', 'b1')"
+
+    # Multiple rows, Multiple columns, implicit template.
+    instance8 = Insert('test', valueList=[{'col1': 'a1', 'col2': 'b1'},
+                                          {'col1': 'a2', 'col2': 'b2'}])
+    assert sqlrepr(instance8, 'mysql') == \
+        "INSERT INTO test (col1, col2) VALUES ('a1', 'b1'), ('a2', 'b2')"
+
+
+def test_update():
+    instance = Update('test', {'test': 'test'})
+    assert sqlrepr(instance, 'mysql') == "UPDATE test SET test='test'"
+
+
+def test_delete():
+    instance = Delete('test', None)
+    assert sqlrepr(instance, 'mysql') == "DELETE FROM test"
+
+
+def test_replace():
+    instance = Replace('test', {'test': 'test'})
+    assert sqlrepr(instance, 'mysql') == "REPLACE test SET test='test'"
+
+
+def test_trueclause():
+    instance = SQLTrueClauseClass()
+    assert sqlrepr(instance) == repr(instance)
+
+
+def test_op():
+    instance = SQLOp('and', 'this', 'that')
+    assert sqlrepr(instance, 'mysql') == "(('this') AND ('that'))"
+
+
+def test_call():
+    instance = SQLCall('test', ('test',))
+    assert sqlrepr(instance, 'mysql') == "'test'('test')"
+
+
+def test_constant():
+    instance = SQLConstant('test')
+    assert sqlrepr(instance) == repr(instance)
+
+
+def test_prefix():
+    instance = SQLPrefix('test', 'test')
+    assert sqlrepr(instance, 'mysql') == "test 'test'"
+
+
+def test_dict():
+    assert sqlrepr({"key": "value"}, "sqlite") == "('key')"
+
+
+def test_sets():
+    try:
+        set
+    except NameError:
+        pass
+    else:
+        assert sqlrepr(set([1])) == "(1)"
+
+
+def test_timedelta():
+    assert sqlrepr(timedelta(seconds=30 * 60)) == \
+        "INTERVAL '0 days 1800 seconds'"
+
+
+def test_quote_unquote_str():
+    assert quote_str('test%', 'postgres') == "'test%'"
+    assert quote_str('test%', 'sqlite') == "'test%'"
+    assert quote_str('test\\%', 'postgres') == "E'test\\%'"
+    assert quote_str('test\\%', 'sqlite') == "'test\\%'"
+    assert unquote_str("'test%'") == 'test%'
+    assert unquote_str("'test\\%'") == 'test\\%'
+    assert unquote_str("E'test\\%'") == 'test\\%'
+
+
+def test_like_quoted():
+    assert sqlrepr(_LikeQuoted('test'), 'postgres') == "'test'"
+    assert sqlrepr(_LikeQuoted('test'), 'sqlite') == "'test'"
+    assert sqlrepr(_LikeQuoted('test%'), 'postgres') == r"E'test\\%'"
+    assert sqlrepr(_LikeQuoted('test%'), 'sqlite') == r"'test\%'"

sqlobject/tests/test_create_drop.py

@@ -0,0 +1,29 @@
+from sqlobject import BLOBCol, DateTimeCol, IntCol, SQLObject, StringCol, \
+    sqlmeta
+from sqlobject.tests.dbtest import getConnection
+
+
+class SOTestCreateDrop(SQLObject):
+    class sqlmeta(sqlmeta):
+        idName = 'test_id_here'
+        table = 'test_create_drop_table'
+    name = StringCol()
+    number = IntCol()
+    so_time = DateTimeCol()
+    short = StringCol(length=10)
+    blobcol = BLOBCol()
+
+
+def test_create_drop():
+    conn = getConnection()
+    SOTestCreateDrop.setConnection(conn)
+    SOTestCreateDrop.dropTable(ifExists=True)
+    assert not conn.tableExists(SOTestCreateDrop.sqlmeta.table)
+    SOTestCreateDrop.createTable(ifNotExists=True)
+    assert conn.tableExists(SOTestCreateDrop.sqlmeta.table)
+    SOTestCreateDrop.createTable(ifNotExists=True)
+    assert conn.tableExists(SOTestCreateDrop.sqlmeta.table)
+    SOTestCreateDrop.dropTable(ifExists=True)
+    assert not conn.tableExists(SOTestCreateDrop.sqlmeta.table)
+    SOTestCreateDrop.dropTable(ifExists=True)
+    assert not conn.tableExists(SOTestCreateDrop.sqlmeta.table)