sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_joins_conditional.py

@@ -0,0 +1,143 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.sqlbuilder import JOIN, LEFTJOIN, LEFTJOINConditional, \
+    LEFTJOINOn, LEFTJOINUsing
+from sqlobject.tests.dbtest import getConnection, setupClass
+
+
+########################################
+# Condiotional joins
+########################################
+
+
+class SOTestJoin1(SQLObject):
+    col1 = StringCol()
+
+
+class SOTestJoin2(SQLObject):
+    col2 = StringCol()
+
+
+class SOTestJoin3(SQLObject):
+    col3 = StringCol()
+
+
+class SOTestJoin4(SQLObject):
+    col4 = StringCol()
+
+
+class SOTestJoin5(SQLObject):
+    col5 = StringCol()
+
+
+def setup():
+    setupClass(SOTestJoin1)
+    setupClass(SOTestJoin2)
+
+
+def test_1syntax():
+    setup()
+    join = JOIN("table1", "table2")
+    assert str(join) == "table1 JOIN table2"
+    join = LEFTJOIN("table1", "table2")
+    assert str(join) == "table1 LEFT JOIN table2"
+    join = LEFTJOINOn("table1", "table2", "tabl1.col1 = table2.col2")
+    assert getConnection().sqlrepr(join) == \
+        "table1 LEFT JOIN table2 ON tabl1.col1 = table2.col2"
+
+
+def test_2select_syntax():
+    setup()
+    select = SOTestJoin1.select(
+        join=LEFTJOINConditional(SOTestJoin1, SOTestJoin2,
+                                 on_condition=(
+                                     SOTestJoin1.q.col1 == SOTestJoin2.q.col2))
+    )
+    assert str(select) == \
+        "SELECT so_test_join1.id, so_test_join1.col1 " \
+        "FROM so_test_join1 " \
+        "LEFT JOIN so_test_join2 " \
+        "ON ((so_test_join1.col1) = (so_test_join2.col2)) WHERE 1 = 1"
+
+
+def test_3perform_join():
+    setup()
+    SOTestJoin1(col1="test1")
+    SOTestJoin1(col1="test2")
+    SOTestJoin1(col1="test3")
+    SOTestJoin2(col2="test1")
+    SOTestJoin2(col2="test2")
+
+    select = SOTestJoin1.select(
+        join=LEFTJOINOn(SOTestJoin1, SOTestJoin2,
+                        SOTestJoin1.q.col1 == SOTestJoin2.q.col2)
+    )
+    assert select.count() == 3
+
+
+def test_4join_3tables_syntax():
+    setup()
+    setupClass(SOTestJoin3)
+
+    select = SOTestJoin1.select(
+        join=LEFTJOIN(SOTestJoin2, SOTestJoin3)
+    )
+    assert str(select) == \
+        "SELECT so_test_join1.id, so_test_join1.col1 " \
+        "FROM so_test_join1, so_test_join2 LEFT JOIN so_test_join3 WHERE 1 = 1"
+
+
+def test_5join_3tables_syntax2():
+    setup()
+    setupClass(SOTestJoin3)
+
+    select = SOTestJoin1.select(
+        join=(LEFTJOIN(None, SOTestJoin2), LEFTJOIN(None, SOTestJoin3))
+    )
+    assert str(select) == \
+        "SELECT so_test_join1.id, so_test_join1.col1 " \
+        "FROM so_test_join1  " \
+        "LEFT JOIN so_test_join2  LEFT JOIN so_test_join3 WHERE 1 = 1"
+
+    select = SOTestJoin1.select(
+        join=(LEFTJOIN(SOTestJoin1, SOTestJoin2),
+              LEFTJOIN(SOTestJoin1, SOTestJoin3))
+    )
+    assert str(select) == \
+        "SELECT so_test_join1.id, so_test_join1.col1 " \
+        "FROM so_test_join1 " \
+        "LEFT JOIN so_test_join2, so_test_join1 " \
+        "LEFT JOIN so_test_join3 WHERE 1 = 1"
+
+
+def test_6join_using():
+    setup()
+    setupClass(SOTestJoin3)
+
+    select = SOTestJoin1.select(
+        join=LEFTJOINUsing(None, SOTestJoin2, [SOTestJoin2.q.id])
+    )
+    assert str(select) == \
+        "SELECT so_test_join1.id, so_test_join1.col1 " \
+        "FROM so_test_join1 " \
+        "LEFT JOIN so_test_join2 USING (so_test_join2.id) WHERE 1 = 1"
+
+
+def test_7join_on():
+    setup()
+    setupClass(SOTestJoin3)
+    setupClass(SOTestJoin4)
+    setupClass(SOTestJoin5)
+
+    select = SOTestJoin1.select(join=(
+        LEFTJOINOn(SOTestJoin2, SOTestJoin3,
+                   SOTestJoin2.q.col2 == SOTestJoin3.q.col3),
+        LEFTJOINOn(SOTestJoin4, SOTestJoin5,
+                   SOTestJoin4.q.col4 == SOTestJoin5.q.col5)
+    ))
+    assert str(select) == \
+        "SELECT so_test_join1.id, so_test_join1.col1 " \
+        "FROM so_test_join1, so_test_join2 " \
+        "LEFT JOIN so_test_join3 " \
+        "ON ((so_test_join2.col2) = (so_test_join3.col3)), so_test_join4 " \
+        "LEFT JOIN so_test_join5 " \
+        "ON ((so_test_join4.col4) = (so_test_join5.col5)) WHERE 1 = 1"

sqlobject/tests/test_jsonbcol.py

@@ -0,0 +1,53 @@
+import pytest
+from sqlobject import SQLObject, JsonbCol
+from sqlobject.tests.dbtest import getConnection, setupClass
+
+
+########################################
+# Jsonb columns
+########################################
+
+
+class JsonbContainer(SQLObject):
+    jsondata = JsonbCol(default=None)
+    jsondata_none = JsonbCol(default=None)
+    jsondata_list = JsonbCol(default=None)
+
+
+dictdata = dict(
+    ship=u'USS Voyager',
+    number='NCC-74656',
+    crew=['Cpt. Janeway', 'Doctor', 'Lt. Torries', 'Seven of Nine'],
+    races=('Borg', 'Kason',),
+    distance2earth=70000,
+    coming_home=True)
+
+nonedata = None
+
+listofdictsdata = [dict(Erath=7390000000),
+                   dict(Vulcan=6000000000),
+                   dict(Kronos='unknown')]
+
+
+def test_jsonbCol():
+    connection = getConnection()
+    if connection.dbName != "postgres":
+        pytest.skip("These tests require PostgreSQL")
+
+    setupClass([JsonbContainer], force=True)
+
+    my_jsonb = JsonbContainer(
+        jsondata=dictdata,
+        jsondata_none=nonedata,
+        jsondata_list=listofdictsdata)
+    iid = my_jsonb.id
+
+    JsonbContainer._connection.cache.clear()
+
+    my_jsonb_2 = JsonbContainer.get(iid)
+
+    assert my_jsonb_2.jsondata['coming_home'] == dictdata['coming_home']
+    assert my_jsonb_2.jsondata['crew'] == dictdata['crew']
+    assert my_jsonb_2.jsondata['races'] == ['Borg', 'Kason']
+    assert my_jsonb_2.jsondata_none is None
+    assert my_jsonb_2.jsondata_list == listofdictsdata

sqlobject/tests/test_jsoncol.py

@@ -0,0 +1,56 @@
+import pytest
+from sqlobject import SQLObject, JSONCol
+from sqlobject.tests.dbtest import setupClass
+
+
+class JSONTest(SQLObject):
+    json = JSONCol(default=None)
+
+
+_json_test_data = (
+    None, True, 1, 2.0,
+    {u"test": [None, True, 1, 2.0,
+     {u"unicode'with'apostrophes": u"unicode\"with\"quotes"},
+     [],
+     u"unicode"]},
+    [None, True, 1, 2.0,
+     [],
+     {u"unicode'with'apostrophes": u"unicode\"with\"quotes"},
+     u"unicode", u"unicode'with'apostrophes", u"unicode\"with\"quotes",
+     ],
+    u"unicode", u"unicode'with'apostrophes", u"unicode\"with\"quotes",
+    {'test': 'Test'},
+)
+
+
+def _setup():
+    setupClass(JSONTest)
+
+    for _id, test_data in enumerate(_json_test_data):
+        JSONTest(id=_id + 1, json=test_data)
+
+
+def test_JSONCol():
+    _setup()
+    JSONTest._connection.cache.clear()
+
+    for _id, test_data in enumerate(_json_test_data):
+        json = JSONTest.get(_id + 1)
+        assert json.json == test_data
+
+
+def test_JSONCol_funcs():
+    connection = JSONTest._connection
+    if not hasattr(connection, 'can_use_json_funcs') \
+            or not connection.can_use_json_funcs():
+        pytest.skip(
+            "The database doesn't support JSON functions; "
+            "JSON functions are supported by MariaDB since version 10.2.7 "
+            "and by MySQL since version 5.7.")
+    _setup()
+
+    rows = list(
+        JSONTest.select(JSONTest.q.json.json_extract('test') == 'Test')
+    )
+    assert len(rows) == 1
+    assert rows[0].json == {'test': 'Test'}

sqlobject/tests/test_lazy.py

@@ -0,0 +1,165 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Lazy updates
+########################################
+
+
+class Lazy(SQLObject):
+
+    class sqlmeta:
+        lazyUpdate = True
+    name = StringCol()
+    other = StringCol(default='nothing')
+    third = StringCol(default='third')
+
+
+class TestLazyTest:
+
+    def setup_method(self, meth):
+        # All this stuff is so that we can track when the connection
+        # does an actual update; we put in a new _SO_update method
+        # that calls the original and sets an instance variable that
+        # we can later check.
+        setupClass(Lazy)
+        self.conn = Lazy._connection
+        self.conn.didUpdate = False
+        self._oldUpdate = self.conn._SO_update
+        newUpdate = (
+            lambda so, values, s=self, c=self.conn, o=self._oldUpdate:
+            self._alternateUpdate(so, values, c, o))
+        self.conn._SO_update = newUpdate
+
+    def teardown_method(self, meth):
+        self.conn._SO_update = self._oldUpdate
+        del self._oldUpdate
+
+    def _alternateUpdate(self, so, values, conn, oldUpdate):
+        conn.didUpdate = True
+        return oldUpdate(so, values)
+
+    def test_lazy(self):
+        assert not self.conn.didUpdate
+        obj = Lazy(name='tim')
+        # We just did an insert, but not an update:
+        assert not self.conn.didUpdate
+        obj.set(name='joe')
+        assert obj.sqlmeta.dirty
+        assert obj.name == 'joe'
+        assert not self.conn.didUpdate
+        obj.syncUpdate()
+        assert obj.name == 'joe'
+        assert self.conn.didUpdate
+        assert not obj.sqlmeta.dirty
+        assert obj.name == 'joe'
+        self.conn.didUpdate = False
+
+        obj = Lazy(name='frank')
+        obj.name = 'joe'
+        assert not self.conn.didUpdate
+        assert obj.sqlmeta.dirty
+        assert obj.name == 'joe'
+        obj.name = 'joe2'
+        assert not self.conn.didUpdate
+        assert obj.sqlmeta.dirty
+        assert obj.name == 'joe2'
+        obj.syncUpdate()
+        assert obj.name == 'joe2'
+        assert not obj.sqlmeta.dirty
+        assert self.conn.didUpdate
+        self.conn.didUpdate = False
+
+        obj = Lazy(name='loaded')
+        assert not obj.sqlmeta.dirty
+        assert not self.conn.didUpdate
+        assert obj.name == 'loaded'
+        obj.name = 'unloaded'
+        assert obj.sqlmeta.dirty
+        assert obj.name == 'unloaded'
+        assert not self.conn.didUpdate
+        obj.sync()
+        assert not obj.sqlmeta.dirty
+        assert obj.name == 'unloaded'
+        assert self.conn.didUpdate
+        self.conn.didUpdate = False
+        obj.name = 'whatever'
+        assert obj.sqlmeta.dirty
+        assert obj.name == 'whatever'
+        assert not self.conn.didUpdate
+        obj._SO_loadValue('name')
+        assert obj.sqlmeta.dirty
+        assert obj.name == 'whatever'
+        assert not self.conn.didUpdate
+        obj._SO_loadValue('other')
+        assert obj.name == 'whatever'
+        assert not self.conn.didUpdate
+        obj.syncUpdate()
+        assert self.conn.didUpdate
+        self.conn.didUpdate = False
+
+        # Now, check that get() doesn't screw
+        # cached objects' validator state.
+        obj_id = obj.id
+        old_state = obj._SO_validatorState
+        obj = Lazy.get(obj_id)
+        assert not obj.sqlmeta.dirty
+        assert not self.conn.didUpdate
+        assert obj._SO_validatorState is old_state
+        assert obj.name == 'whatever'
+        obj.name = 'unloaded'
+        assert obj.name == 'unloaded'
+        assert obj.sqlmeta.dirty
+        assert not self.conn.didUpdate
+        # Fetch the object again with get() and
+        # make sure sqlmeta.dirty is still set, as the
+        # object should come from the cache.
+        obj = Lazy.get(obj_id)
+        assert obj.sqlmeta.dirty
+        assert not self.conn.didUpdate
+        assert obj.name == 'unloaded'
+        obj.syncUpdate()
+        assert self.conn.didUpdate
+        assert not obj.sqlmeta.dirty
+        self.conn.didUpdate = False
+
+        # Then clear the cache, and try a get()
+        # again, to make sure stuf like _SO_createdValues
+        # is properly initialized.
+        self.conn.cache.clear()
+        obj = Lazy.get(obj_id)
+        assert not obj.sqlmeta.dirty
+        assert not self.conn.didUpdate
+        assert obj.name == 'unloaded'
+        obj.name = 'spongebob'
+        assert obj.name == 'spongebob'
+        assert obj.sqlmeta.dirty
+        assert not self.conn.didUpdate
+        obj.syncUpdate()
+        assert self.conn.didUpdate
+        assert not obj.sqlmeta.dirty
+        self.conn.didUpdate = False
+
+        obj = Lazy(name='last')
+        assert not obj.sqlmeta.dirty
+        obj.syncUpdate()
+        assert not self.conn.didUpdate
+        assert not obj.sqlmeta.dirty
+        # Check that setting multiple values
+        # actually works. This was broken
+        # and just worked because we were testing
+        # only one value at a time, so 'name'
+        # had the right value after the for loop *wink*
+        # Also, check that passing a name that is not
+        # a valid column doesn't break, but instead
+        # just does a plain setattr.
+        obj.set(name='first', other='who', third='yes')
+        assert obj.name == 'first'
+        assert obj.other == 'who'
+        assert obj.third == 'yes'
+        assert obj.sqlmeta.dirty
+        assert not self.conn.didUpdate
+        obj.syncUpdate()
+        assert self.conn.didUpdate
+        assert not obj.sqlmeta.dirty

sqlobject/tests/test_md5.py

@@ -0,0 +1,13 @@
+from hashlib import md5
+
+
+########################################
+# hashlib.md5
+########################################
+
+
+def test_md5():
+    assert md5(b'').hexdigest() == 'd41d8cd98f00b204e9800998ecf8427e'
+    assert md5(b'\n').hexdigest() == '68b329da9893e34099c7d8ad5cb9c940'
+    assert md5(b'123').hexdigest() == '202cb962ac59075b964b07152d234b70'
+    assert md5(b'123\n').hexdigest() == 'ba1f2511fc30423bdbb183fe33f3dd0f'

sqlobject/tests/test_mysql.py

@@ -0,0 +1,50 @@
+import pytest
+from sqlobject import SQLObject, IntCol
+from sqlobject.sqlbuilder import Select, ANY
+from sqlobject.tests.dbtest import getConnection, setupClass
+
+
+try:
+    connection = getConnection()
+except (AttributeError, NameError):
+    # The module was imported during documentation building
+    pass
+else:
+    if connection.dbName != "mysql":
+        pytestmark = pytest.mark.skip("These tests require MySQL")
+
+
+class SOTestSOListMySQL(SQLObject):
+    pass
+
+
+def test_list_databases():
+    assert connection.db in connection.listDatabases()
+
+
+def test_list_tables():
+    setupClass(SOTestSOListMySQL)
+    assert SOTestSOListMySQL.sqlmeta.table in connection.listTables()
+
+
+class SOTestANY(SQLObject):
+    value = IntCol()
+
+
+def test_ANY():
+    setupClass(SOTestANY)
+    SOTestANY(value=10)
+    SOTestANY(value=20)
+    SOTestANY(value=30)
+    assert len(list(SOTestANY.select(
+        SOTestANY.q.value > ANY(Select([SOTestANY.q.value]))))) == 2
+
+
+class SOTestMySQLidSize(SQLObject):
+    class sqlmeta:
+        idSize = 'BIG'
+
+
+def test_idSize():
+    assert 'id BIGINT PRIMARY KEY AUTO_INCREMENT' \
+        in SOTestMySQLidSize.createTableSQL(connection=connection)[0]

sqlobject/tests/test_new_joins.py

@@ -0,0 +1,165 @@
+from __future__ import print_function
+
+from sqlobject import ForeignKey, ManyToMany, OneToMany, SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Joins
+########################################
+
+
+class PersonJNew(SQLObject):
+
+    name = StringCol(length=40, alternateID=True)
+    addressJs = ManyToMany('AddressJNew')
+
+
+class AddressJNew(SQLObject):
+
+    zip = StringCol(length=5, alternateID=True)
+    personJs = ManyToMany('PersonJNew')
+
+
+class ImplicitJoiningSONew(SQLObject):
+    foo = ManyToMany('Bar')
+
+
+class ExplicitJoiningSONew(SQLObject):
+    foo = OneToMany('Bar')
+
+
+class TestJoin:
+
+    def setup_method(self, meth):
+        setupClass(PersonJNew)
+        setupClass(AddressJNew)
+        for n in ['bob', 'tim', 'jane', 'joe', 'fred', 'barb']:
+            PersonJNew(name=n)
+        for z in ['11111', '22222', '33333', '44444']:
+            AddressJNew(zip=z)
+
+    def test_join(self):
+        b = PersonJNew.byName('bob')
+        assert list(b.addressJs) == []
+        z = AddressJNew.byZip('11111')
+        b.addressJs.add(z)
+        self.assertZipsEqual(b.addressJs, ['11111'])
+        print(str(z.personJs), repr(z.personJs))
+        self.assertNamesEqual(z.personJs, ['bob'])
+        z2 = AddressJNew.byZip('22222')
+        b.addressJs.add(z2)
+        print(str(b.addressJs))
+        self.assertZipsEqual(b.addressJs, ['11111', '22222'])
+        self.assertNamesEqual(z2.personJs, ['bob'])
+        b.addressJs.remove(z)
+        self.assertZipsEqual(b.addressJs, ['22222'])
+        self.assertNamesEqual(z.personJs, [])
+
+    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 PersonJNew2(SQLObject):
+
+    name = StringCol('name', length=40, alternateID=True)
+    addressJ2s = OneToMany('AddressJNew2')
+
+
+class AddressJNew2(SQLObject):
+
+    class sqlmeta:
+        defaultOrder = ['-zip', 'plus4']
+
+    zip = StringCol(length=5)
+    plus4 = StringCol(length=4, default=None)
+    personJNew2 = ForeignKey('PersonJNew2')
+
+
+class TestJoin2:
+
+    def setup_method(self, meth):
+        setupClass([PersonJNew2, AddressJNew2])
+        p1 = PersonJNew2(name='bob')
+        p2 = PersonJNew2(name='sally')
+        for z in ['11111', '22222', '33333']:
+            AddressJNew2(zip=z, personJNew2=p1)
+        AddressJNew2(zip='00000', personJNew2=p2)
+
+    def test_basic(self):
+        bob = PersonJNew2.byName('bob')
+        sally = PersonJNew2.byName('sally')
+        print(bob.addressJ2s)
+        print(bob)
+        assert len(list(bob.addressJ2s)) == 3
+        assert len(list(sally.addressJ2s)) == 1
+        bob.addressJ2s[0].destroySelf()
+        assert len(list(bob.addressJ2s)) == 2
+        z = bob.addressJ2s[0]
+        z.zip = 'xxxxx'
+        id = z.id
+        del z
+        z = AddressJNew2.get(id)
+        assert z.zip == 'xxxxx'
+
+    def test_defaultOrder(self):
+        p1 = PersonJNew2.byName('bob')
+        assert ([i.zip for i in p1.addressJ2s]
+                == ['33333', '22222', '11111'])
+
+
+_personJ3_getters = []
+_personJ3_setters = []
+
+
+class PersonJNew3(SQLObject):
+
+    name = StringCol('name', length=40, alternateID=True)
+    addressJNew3s = OneToMany('AddressJNew3')
+
+
+class AddressJNew3(SQLObject):
+
+    zip = StringCol(length=5)
+    personJNew3 = ForeignKey('PersonJNew3')
+
+    def _get_personJNew3(self):
+        value = self._SO_get_personJNew3()
+        _personJ3_getters.append((self, value))
+        return value
+
+    def _set_personJNew3(self, value):
+        self._SO_set_personJNew3(value)
+        _personJ3_setters.append((self, value))
+
+
+class TestJoin3:
+
+    def setup_method(self, meth):
+        setupClass([PersonJNew3, AddressJNew3])
+        p1 = PersonJNew3(name='bob')
+        p2 = PersonJNew3(name='sally')
+        for z in ['11111', '22222', '33333']:
+            AddressJNew3(zip=z, personJNew3=p1)
+        AddressJNew3(zip='00000', personJNew3=p2)
+
+    def test_accessors(self):
+        assert len(list(_personJ3_getters)) == 0
+        assert len(list(_personJ3_setters)) == 4
+        bob = PersonJNew3.byName('bob')
+        for addressJ3 in bob.addressJNew3s:
+            addressJ3.personJNew3
+        assert len(list(_personJ3_getters)) == 3
+        assert len(list(_personJ3_setters)) == 4