sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_parse_uri.py

@@ -0,0 +1,147 @@
+import os
+from sqlobject.dbconnection import DBConnection
+from sqlobject.sqlite.sqliteconnection import SQLiteConnection
+
+
+########################################
+# Test _parseURI
+########################################
+
+
+def test_parse():
+    _parseURI = DBConnection._parseURI
+
+    user, password, host, port, path, args = _parseURI("mysql://host/database")
+    assert user is None
+    assert password is None
+    assert host == "host"
+    assert port is None
+    assert path == "/database"
+    assert args == {}
+
+    user, password, host, port, path, args = _parseURI(
+        "mysql://user:pass%20word@host/database?unix_socket=/var/mysql/socket")
+    assert user == "user"
+    assert password == "pass word"
+    assert host == "host"
+    assert port is None
+    assert path == "/database"
+    assert args == {"unix_socket": "/var/mysql/socket"}
+
+    user, password, host, port, path, args = \
+        _parseURI("postgres://user@host/database")
+    assert user == "user"
+    assert password is None
+    assert host == "host"
+    assert port is None
+    assert path == "/database"
+    assert args == {}
+
+    user, password, host, port, path, args = \
+        _parseURI("postgres://host:5432/database")
+    assert user is None
+    assert password is None
+    assert host == "host"
+    assert port == 5432
+    assert path == "/database"
+    assert args == {}
+
+    user, password, host, port, path, args = \
+        _parseURI("postgres:///full/path/to/socket/database")
+    assert user is None
+    assert password is None
+    assert host is None
+    assert port is None
+    assert path == "/full/path/to/socket/database"
+    assert args == {}
+
+    user, password, host, port, path, args = \
+        _parseURI("postgres://us%3Aer:p%40ssword@host/database")
+    assert user == "us:er"
+    assert password == "p@ssword"
+    assert host == "host"
+    assert port is None
+    assert path == "/database"
+    assert args == {}
+
+    user, password, host, port, path, args = \
+        _parseURI("sqlite:///full/path/to/database")
+    assert user is None
+    assert password is None
+    assert host is None
+    assert port is None
+    assert path == "/full/path/to/database"
+    assert args == {}
+
+    user, password, host, port, path, args = _parseURI("sqlite:/:memory:")
+    assert user is None
+    assert password is None
+    assert host is None
+    assert port is None
+    assert path == "/:memory:"
+    assert args == {}
+
+    if os.name == 'nt':
+        user, password, host, port, path, args = \
+            _parseURI("sqlite:/C|/full/path/to/database")
+        assert user is None
+        assert password is None
+        assert host is None
+        assert port is None
+        assert path == "C:/full/path/to/database"
+        assert args == {}
+
+        user, password, host, port, path, args = \
+            _parseURI("sqlite:///C:/full/path/to/database")
+        assert user is None
+        assert password is None
+        assert host is None
+        assert port is None
+        assert path == "C:/full/path/to/database"
+        assert args == {}
+
+
+def test_uri():
+    connection = DBConnection()
+    connection.close = lambda: None
+
+    connection.dbName, connection.host, connection.port, \
+        connection.user, connection.password, connection.db = \
+        'mysql', 'host', None, None, None, 'database'
+    assert connection.uri() == "mysql://host/database"
+
+    connection.dbName, connection.host, connection.port, \
+        connection.user, connection.password, connection.db = \
+        'mysql', 'host', None, 'user', 'pass word', 'database'
+    assert connection.uri() == "mysql://user:pass%20word@host/database"
+
+    connection.dbName, connection.host, connection.port, \
+        connection.user, connection.password, connection.db = \
+        'postgres', 'host', None, 'user', None, 'database'
+    assert connection.uri() == "postgres://user@host/database"
+
+    connection.dbName, connection.host, connection.port, \
+        connection.user, connection.password, connection.db = \
+        'postgres', 'host', 5432, None, None, 'database'
+    assert connection.uri() == "postgres://host:5432/database"
+
+    connection.dbName, connection.host, connection.port, \
+        connection.user, connection.password, connection.db = \
+        'postgres', None, None, None, None, '/full/path/to/socket/database'
+    assert connection.uri() == "postgres:///full/path/to/socket/database"
+
+    connection.dbName, connection.host, connection.port, \
+        connection.user, connection.password, connection.db = \
+        'postgres', 'host', None, 'us:er', 'p@ssword', 'database'
+    assert connection.uri() == "postgres://us%3Aer:p%40ssword@host/database"
+
+    connection = SQLiteConnection(None)
+    connection.filename = '/full/path/to/database'
+    assert connection.uri() == "sqlite:///full/path/to/database"
+
+    connection.filename = ':memory:'
+    assert connection.uri() == "sqlite:/:memory:"
+
+    if os.name == 'nt':
+        connection.filename = 'C:/full/path/to/database'
+        assert connection.uri() == "sqlite:///C%3A/full/path/to/database"

sqlobject/tests/test_paste.py

@@ -0,0 +1,92 @@
+from __future__ import print_function
+import pytest
+
+from sqlobject import sqlhub, SQLObject, StringCol
+try:
+    from sqlobject.wsgi_middleware import make_middleware
+except ImportError:
+    pytestmark = pytest.mark.skipif(True, reason='These tests require Paste')
+from .dbtest import getConnection, getConnectionURI, setupClass
+
+
+class NameOnly(SQLObject):
+    name = StringCol()
+
+
+def makeapp(abort=False, begin=False, fail=False):
+    def app(environ, start_response):
+        NameOnly(name='app1')
+        if fail == 'early':
+            assert 0
+        start_response('200 OK', [('content-type', 'text/plain')])
+        if begin:
+            environ['sqlobject.begin']()
+        NameOnly(name='app2')
+        if abort:
+            environ['sqlobject.abort']()
+        if fail:
+            assert 0
+        return ['ok']
+    return app
+
+
+def makestack(abort=False, begin=False, fail=False, **kw):
+    app = makeapp(abort=abort, begin=begin, fail=fail)
+    app = make_middleware(app, {}, database=getConnectionURI(), **kw)
+    return app
+
+
+def runapp(**kw):
+    print('-' * 8)
+    app = makestack(**kw)
+    env = {}
+
+    def start_response(*args):
+        pass
+
+    try:
+        list(app(env, start_response))
+        return True
+    except AssertionError:
+        return False
+
+
+def setup():
+    setupClass(NameOnly)
+    getConnection().query('DELETE FROM name_only')
+    NameOnly._connection = sqlhub
+
+
+def names():
+    names = [n.name for n in NameOnly.select(connection=getConnection())]
+    names.sort()
+    return names
+
+
+def test_fail():
+    setup()
+    assert not runapp(fail=True, use_transaction=True)
+    assert names() == []
+    setup()
+    assert not runapp(fail=True, use_transaction=False)
+    assert names() == ['app1', 'app2']
+    setup()
+    assert not runapp(fail=True, begin=True, use_transaction=True)
+    assert names() == ['app1']
+
+
+def test_other():
+    setup()
+    assert runapp(fail=False, begin=True, use_transaction=True)
+    assert names() == ['app1', 'app2']
+    setup()
+    # @@: Dammit, I can't get these to pass because I can't get the
+    # stupid table to clear itself.  setupClass() sucks.  When I
+    # fix it I'll take this disabling out:
+    pytest.skip("Oops...")
+    assert names() == []
+    assert runapp(fail=False, begin=True, abort=True, use_transaction=True)
+    assert names() == ['app1']
+    setup()
+    assert runapp(use_transaction=True)
+    assert names() == ['app1', 'app2']

sqlobject/tests/test_perConnection.py

@@ -0,0 +1,20 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.tests.dbtest import getConnection
+
+
+########################################
+# Per-instance connection
+########################################
+
+
+class SOTestPerConnection(SQLObject):
+    test = StringCol()
+
+
+def test_perConnection():
+    connection = getConnection()
+    SOTestPerConnection.dropTable(connection=connection, ifExists=True)
+    SOTestPerConnection.createTable(connection=connection)
+    SOTestPerConnection(test='test', connection=connection)
+    assert len(list(SOTestPerConnection.select(
+        SOTestPerConnection.q.test == 'test', connection=connection))) == 1

sqlobject/tests/test_pickle.py

@@ -0,0 +1,42 @@
+import pickle
+import pytest
+from sqlobject import IntCol, SQLObject, StringCol
+from sqlobject.tests.dbtest import getConnection, raises, setupClass
+
+
+########################################
+# Pickle instances
+########################################
+
+
+class SOTestPickle(SQLObject):
+    question = StringCol()
+    answer = IntCol()
+
+
+test_question = 'The Ulimate Question of Life, the Universe and Everything'
+test_answer = 42
+
+
+def test_pickleCol():
+    setupClass(SOTestPickle)
+    connection = SOTestPickle._connection
+    test = SOTestPickle(question=test_question, answer=test_answer)
+
+    pickle_data = pickle.dumps(test, pickle.HIGHEST_PROTOCOL)
+    connection.cache.clear()
+    test = pickle.loads(pickle_data)
+    test2 = connection.cache.tryGet(test.id, SOTestPickle)
+
+    assert test2 is test
+    assert test.question == test_question
+    assert test.answer == test_answer
+
+    if (connection.dbName == 'sqlite') and connection._memory:
+        pytest.skip("The following test requires a different connection")
+
+    test = SOTestPickle.get(
+        test.id,
+        # make a different DB URI and open another connection
+        connection=getConnection(registry=''))
+    raises(pickle.PicklingError, pickle.dumps, test, pickle.HIGHEST_PROTOCOL)

sqlobject/tests/test_picklecol.py

@@ -0,0 +1,44 @@
+import pytest
+from sqlobject import PickleCol, SQLObject
+from sqlobject.tests.dbtest import setupClass, supports
+
+
+########################################
+# Pickle columns
+########################################
+
+
+class PickleData:
+    pi = 3.14156
+
+    def __init__(self):
+        self.question = \
+            'The Ulimate Question of Life, the Universe and Everything'
+        self.answer = 42
+
+
+class PickleContainer(SQLObject):
+    pickledata = PickleCol(default=None, length=256)
+
+
+def test_pickleCol():
+    if not supports('blobData'):
+        pytest.skip("blobData isn't supported")
+    setupClass([PickleContainer], force=True)
+    mypickledata = PickleData()
+
+    ctnr = PickleContainer(pickledata=mypickledata)
+    iid = ctnr.id
+
+    PickleContainer._connection.cache.clear()
+
+    ctnr2 = PickleContainer.get(iid)
+    s2 = ctnr2.pickledata
+
+    assert isinstance(s2, PickleData)
+    assert isinstance(s2.pi, float)
+    assert isinstance(s2.question, str)
+    assert isinstance(s2.answer, int)
+    assert s2.pi == mypickledata.pi
+    assert s2.question == mypickledata.question
+    assert s2.answer == mypickledata.answer

sqlobject/tests/test_postgres.py

@@ -0,0 +1,82 @@
+import os
+import pytest
+from sqlobject import SQLObject, StringCol, IntCol
+from sqlobject.sqlbuilder import Select, SOME
+from sqlobject.tests.dbtest import getConnection, setupClass
+
+
+########################################
+# Test PosgreSQL sslmode
+########################################
+
+
+try:
+    connection = getConnection()
+except (AttributeError, NameError):
+    # The module was imported during documentation building
+    pass
+else:
+    if connection.dbName != "postgres":
+        pytestmark = pytest.mark.skip("These tests require PostgreSQL")
+
+
+class SOTestSSLMode(SQLObject):
+    test = StringCol()
+
+
+def test_sslmode():
+    setupClass(SOTestSSLMode)
+    connection = SOTestSSLMode._connection
+    if (not connection.module.__name__.startswith('psycopg')) or \
+            (os.name == 'nt'):
+        pytest.skip("The test requires PostgreSQL, psycopg and ssl mode; "
+                    "also it doesn't work on w32")
+
+    connection = getConnection(sslmode='require')
+    SOTestSSLMode._connection = connection
+    test = SOTestSSLMode(test='test')  # Connect to the DB to test sslmode
+
+    connection.cache.clear()
+    test = SOTestSSLMode.select()[0]
+    assert test.test == 'test'
+
+
+########################################
+# Test PosgreSQL list{Database,Tables}
+########################################
+
+
+class SOTestSOList(SQLObject):
+    pass
+
+
+def test_list_databases():
+    assert connection.db in connection.listDatabases()
+
+
+def test_list_tables():
+    setupClass(SOTestSOList)
+    assert SOTestSOList.sqlmeta.table in connection.listTables()
+
+
+class SOTestSOME(SQLObject):
+    value = IntCol()
+
+
+def test_SOME():
+    setupClass(SOTestSOME)
+    SOTestSOME(value=10)
+    SOTestSOME(value=20)
+    SOTestSOME(value=30)
+    assert len(list(SOTestSOME.select(
+        SOTestSOME.q.value > SOME(Select([SOTestSOME.q.value]))))) == 2
+
+
+class SOTestPgidSize(SQLObject):
+    class sqlmeta:
+        idSize = 'BIG'
+
+
+def test_idSize():
+    assert 'id BIGSERIAL PRIMARY KEY' \
+        in SOTestPgidSize.createTableSQL(connection=connection)[0]

sqlobject/tests/test_reparent_sqlmeta.py

@@ -0,0 +1,33 @@
+from sqlobject import SQLObject, StringCol, sqlmeta
+from sqlobject.tests.dbtest import setupClass
+
+real_sqlmeta = sqlmeta
+
+
+class Reparented1(SQLObject):
+
+    class sqlmeta:
+        table = 'reparented1'
+
+    dummy = StringCol()
+
+
+class Reparented2(SQLObject):
+    class sqlmeta(object):
+        @classmethod
+        def setClass(cls, soClass):
+            # Well, it's pretty hard to call the superclass method
+            # when it's a classmethod and it's not actually your
+            # *current* superclass.  Sigh
+            real_sqlmeta.setClass.__func__(cls, soClass)
+            cls.worked = True
+
+    dummy = StringCol()
+
+
+def test_reparented():
+    setupClass([Reparented1, Reparented2])
+    assert Reparented1.sqlmeta.table == 'reparented1'
+    assert issubclass(Reparented1.sqlmeta, real_sqlmeta)
+    assert issubclass(Reparented2.sqlmeta, real_sqlmeta)
+    assert Reparented2.sqlmeta.worked

sqlobject/tests/test_schema.py

@@ -0,0 +1,30 @@
+import pytest
+from sqlobject import SQLObject, UnicodeCol
+from sqlobject.tests.dbtest import getConnection, setupClass, supports
+
+
+########################################
+# Schema per connection
+########################################
+
+
+class SOTestSchema(SQLObject):
+    foo = UnicodeCol(length=200)
+
+
+def test_connection_schema():
+    if not supports('schema'):
+        pytest.skip("schemas aren't supported")
+    conn = getConnection()
+    conn.schema = None
+    conn.query('CREATE SCHEMA test')
+    conn.schema = 'test'
+    conn.query('SET search_path TO test')
+    setupClass(SOTestSchema)
+    assert SOTestSchema._connection is conn
+    try:
+        SOTestSchema(foo='bar')
+        assert conn.queryAll("SELECT * FROM test.so_test_schema")
+    finally:
+        conn.schema = None
+        conn.query('SET search_path TO public')