def test_comparison(self):
components = (
"drivername",
"username",
"password",
"host",
"database",
"query",
"port",
)
common_url = (
"dbtype://*****:*****@[2001:da8:2004:1000:202:116:160:90]:80/database?foo=bar"
)
other_url = "dbtype://*****:*****@host/"
url1 = url.make_url(common_url)
url2 = url.make_url(common_url)
url3 = url.make_url(other_url)
is_true(url1 == url2)
is_false(url1 != url2)
is_true(url1 != url3)
is_false(url1 == url3)
for curr_component in components:
setattr(url2, curr_component, "new_changed_value")
is_true(url1 != url2)
is_false(url1 == url2)
setattr(url2, curr_component, getattr(url1, curr_component))
def test_rfc1738_password(self):
u = url.make_url("dbtype://*****:*****@host/dbname")
eq_(u.password, "pass word + other:words")
eq_(str(u), "dbtype://*****:*****@host/dbname")
u = url.make_url(
"dbtype://*****:*****@hostspec/database"
)
eq_(u.password, "apples/oranges")
eq_(str(u), "dbtype://*****:*****@hostspec/database")
u = url.make_url(
"dbtype://*****:*****@hostspec/database"
)
eq_(u.password, "apples@oranges@@")
eq_(
str(u),
"dbtype://*****:*****@hostspec/database",
)
u = url.make_url("dbtype://username%40:@hostspec/database")
eq_(u.password, "")
eq_(u.username, "username@")
eq_(str(u), "dbtype://username%40:@hostspec/database")
u = url.make_url("dbtype://*****:*****@hostspec/database")
eq_(u.password, "pass/word")
eq_(str(u), "dbtype://*****:*****@hostspec/database")
def test_plugin_multiple_url_registration(self):
from sqlalchemy_1_3.dialects import sqlite
global MyEnginePlugin1
global MyEnginePlugin2
def side_effect_1(url, kw):
eq_(kw, {"logging_name": "foob"})
kw["logging_name"] = "bar"
url.query.pop("myplugin1_arg", None)
return MyEnginePlugin1
def side_effect_2(url, kw):
url.query.pop("myplugin2_arg", None)
return MyEnginePlugin2
MyEnginePlugin1 = Mock(side_effect=side_effect_1)
MyEnginePlugin2 = Mock(side_effect=side_effect_2)
plugins.register("engineplugin1", __name__, "MyEnginePlugin1")
plugins.register("engineplugin2", __name__, "MyEnginePlugin2")
e = create_engine(
"sqlite:///?plugin=engineplugin1&foo=bar&myplugin1_arg=bat"
"&plugin=engineplugin2&myplugin2_arg=hoho",
logging_name="foob",
)
eq_(e.dialect.name, "sqlite")
eq_(e.logging_name, "bar")
# plugin args are removed from URL.
eq_(e.url.query, {"foo": "bar"})
assert isinstance(e.dialect, sqlite.dialect)
eq_(
MyEnginePlugin1.mock_calls,
[
call(url.make_url("sqlite:///?foo=bar"), {}),
call.handle_dialect_kwargs(sqlite.dialect, mock.ANY),
call.handle_pool_kwargs(mock.ANY, {"dialect": e.dialect}),
call.engine_created(e),
],
)
eq_(
MyEnginePlugin2.mock_calls,
[
call(url.make_url("sqlite:///?foo=bar"), {}),
call.handle_dialect_kwargs(sqlite.dialect, mock.ANY),
call.handle_pool_kwargs(mock.ANY, {"dialect": e.dialect}),
call.engine_created(e),
],
)
def test_psycopg2_nonempty_connection_string_w_query_two(self):
dialect = psycopg2_dialect.dialect()
url_string = "postgresql://*****:*****@/DB?host=hostA"
u = url.make_url(url_string)
cargs, cparams = dialect.create_connect_args(u)
eq_(cargs, [])
eq_(cparams["host"], "hostA")
def test_threaded_deprecated_at_dialect_level(self):
with testing.expect_deprecated(
"The 'threaded' parameter to the cx_oracle dialect"):
dialect = cx_oracle.dialect(threaded=False)
arg, kw = dialect.create_connect_args(
url.make_url("oracle+cx_oracle://scott:tiger@dsn"))
eq_(kw["threaded"], False)
def _test_db_opt_unpresent(self, url_string, key):
import cx_Oracle
url_obj = url.make_url(url_string)
dialect = cx_oracle.dialect(dbapi=cx_Oracle)
arg, kw = dialect.create_connect_args(url_obj)
assert key not in kw
def _test_db_opt(self, url_string, key, value):
import cx_Oracle
url_obj = url.make_url(url_string)
dialect = cx_oracle.dialect(dbapi=cx_Oracle)
arg, kw = dialect.create_connect_args(url_obj)
eq_(kw[key], value)
def _test_ssl_arguments(self, dialect):
kwarg = dialect.create_connect_args(
make_url(
"mysql://*****:*****@localhost:3306/test"
"?ssl_ca=/ca.pem&ssl_cert=/cert.pem&ssl_key=/key.pem"
)
)[1]
# args that differ among mysqldb and oursql
for k in ("use_unicode", "found_rows", "client_flag"):
kwarg.pop(k, None)
eq_(
kwarg,
{
"passwd": "tiger",
"db": "test",
"ssl": {
"ca": "/ca.pem",
"cert": "/cert.pem",
"key": "/key.pem",
},
"host": "localhost",
"user": "******",
"port": 3306,
},
)
def test_wrapper_hooks(self):
def get_dialect_cls(url):
url.drivername = "sqlite"
return url.get_dialect()
global WrapperFactory
WrapperFactory = Mock()
WrapperFactory.get_dialect_cls.side_effect = get_dialect_cls
registry.register("wrapperdialect", __name__, "WrapperFactory")
from sqlalchemy_1_3.dialects import sqlite
e = create_engine("wrapperdialect://")
eq_(e.dialect.name, "sqlite")
assert isinstance(e.dialect, sqlite.dialect)
eq_(
WrapperFactory.mock_calls,
[
call.get_dialect_cls(url.make_url("sqlite://")),
call.engine_created(e),
],
)
def test_query_string(self):
u = url.make_url("dialect://*****:*****@host/db?arg1=param1&arg2=param2")
eq_(u.query, {"arg1": "param1", "arg2": "param2"})
eq_(str(u), "dialect://*****:*****@host/db?arg1=param1&arg2=param2")
u = url.make_url(
"dialect://*****:*****@host/db?arg1=param1&arg2=param2&arg2=param3"
)
eq_(u.query, {"arg1": "param1", "arg2": ["param2", "param3"]})
eq_(
str(u),
"dialect://*****:*****@host/db?arg1=param1&arg2=param2&arg2=param3",
)
test_url = "dialect://*****:*****@host/db?arg1%3D=param1&arg2=param+2"
u = url.make_url(test_url)
eq_(u.query, {"arg1=": "param1", "arg2": "param 2"})
eq_(str(u), test_url)
def test_mysqlconnector_buffered_arg(self):
from sqlalchemy_1_3.dialects.mysql import mysqlconnector
dialect = mysqlconnector.dialect()
kw = dialect.create_connect_args(
make_url("mysql+mysqlconnector://u:p@host/db?buffered=true")
)[1]
eq_(kw["buffered"], True)
kw = dialect.create_connect_args(
make_url("mysql+mysqlconnector://u:p@host/db?buffered=false")
)[1]
eq_(kw["buffered"], False)
kw = dialect.create_connect_args(
make_url("mysql+mysqlconnector://u:p@host/db")
)[1]
eq_(kw["buffered"], True)
def test_psycopg2_nonempty_connection_string_w_query_three(self):
dialect = psycopg2_dialect.dialect()
url_string = (
"postgresql://*****:*****@/DB"
"?host=hostA:portA&host=hostB&host=hostC"
)
u = url.make_url(url_string)
cargs, cparams = dialect.create_connect_args(u)
eq_(cargs, [])
eq_(cparams["host"], "hostA:portA,hostB,hostC")
def test_normal_arguments_mysqldb(self, kwarg, value):
from sqlalchemy_1_3.dialects.mysql import mysqldb
dialect = mysqldb.dialect()
connect_args = dialect.create_connect_args(
make_url(
"mysql://*****:*****@localhost:3306/test"
"?%s=%s" % (kwarg, value)
)
)
eq_(connect_args[1][kwarg], value)
def _test_dialect_param_from_url(self, url_string, key, value):
import cx_Oracle
url_obj = url.make_url(url_string)
dialect = cx_oracle.dialect(dbapi=cx_Oracle)
with testing.expect_deprecated("cx_oracle dialect option %r should" %
key):
arg, kw = dialect.create_connect_args(url_obj)
eq_(getattr(dialect, key), value)
# test setting it on the dialect normally
dialect = cx_oracle.dialect(dbapi=cx_Oracle, **{key: value})
eq_(getattr(dialect, key), value)
def test_mysqlconnector_raise_on_warnings_arg(self):
from sqlalchemy_1_3.dialects.mysql import mysqlconnector
dialect = mysqlconnector.dialect()
kw = dialect.create_connect_args(
make_url(
"mysql+mysqlconnector://u:p@host/db?raise_on_warnings=true"
)
)[1]
eq_(kw["raise_on_warnings"], True)
kw = dialect.create_connect_args(
make_url(
"mysql+mysqlconnector://u:p@host/db?raise_on_warnings=false"
)
)[1]
eq_(kw["raise_on_warnings"], False)
kw = dialect.create_connect_args(
make_url("mysql+mysqlconnector://u:p@host/db")
)[1]
assert "raise_on_warnings" not in kw
def _pool_fixture(self, pre_ping):
dialect = url.make_url(
"postgresql://*****:*****@localhost/test").get_dialect()()
dialect.dbapi = self.dbapi
_pool = pool.QueuePool(
creator=lambda: self.dbapi.connect("foo.db"),
pre_ping=pre_ping,
dialect=dialect,
)
dialect.is_disconnect = lambda e, conn, cursor: isinstance(
e, MockDisconnect)
return _pool
def test_rfc1738(self):
for text in (
"dbtype://*****:*****@hostspec:110//usr/db_file.db",
"dbtype://*****:*****@hostspec/database",
"dbtype+apitype://username:password@hostspec/database",
"dbtype://*****:*****@hostspec",
"dbtype://*****:*****@/database",
"dbtype://username@hostspec",
"dbtype://*****:*****@127.0.0.1:1521",
"dbtype://hostspec/database",
"dbtype://hostspec",
"dbtype://hostspec/?arg1=val1&arg2=val2",
"dbtype+apitype:///database",
"dbtype:///:memory:",
"dbtype:///foo/bar/im/a/file",
"dbtype:///E:/work/src/LEM/db/hello.db",
"dbtype:///E:/work/src/LEM/db/hello.db?foo=bar&hoho=lala",
"dbtype:///E:/work/src/LEM/db/hello.db?foo=bar&hoho=lala&hoho=bat",
"dbtype://",
"dbtype://*****:*****@/database",
"dbtype:////usr/local/[email protected]/members.db",
"dbtype://*****:*****@hostspec/database",
"dbtype://*****:*****@[2001:da8:2004:1000:202:116:160:90]"
"/database?foo=bar",
"dbtype://*****:*****@[2001:da8:2004:1000:202:116:160:90]:80"
"/database?foo=bar",
):
u = url.make_url(text)
assert u.drivername in ("dbtype", "dbtype+apitype")
assert u.username in ("username", None)
assert u.password in ("password", "apples/oranges", None)
assert u.host in (
"hostspec",
"127.0.0.1",
"2001:da8:2004:1000:202:116:160:90",
"",
None,
), u.host
assert u.database in (
"database",
"/usr/local/[email protected]/members.db",
"/usr/db_file.db",
":memory:",
"",
"foo/bar/im/a/file",
"E:/work/src/LEM/db/hello.db",
None,
), u.database
eq_(str(u), text)
def test_engine_from_config(self):
dbapi = mock_dbapi
config = {
"sqlalchemy.url": "postgresql://*****:*****@somehost/test"
"?fooz=somevalue",
"sqlalchemy.pool_recycle": "50",
"sqlalchemy.echo": "true",
}
e = engine_from_config(config, module=dbapi, _initialize=False)
assert e.pool._recycle == 50
assert e.url == url.make_url(
"postgresql://*****:*****@somehost/test?foo" "z=somevalue"
)
assert e.echo is True
def test_plugin_url_registration(self):
from sqlalchemy_1_3.dialects import sqlite
global MyEnginePlugin
def side_effect(url, kw):
eq_(
url.query,
{
"plugin": "engineplugin",
"myplugin_arg": "bat",
"foo": "bar",
},
)
eq_(kw, {"logging_name": "foob"})
kw["logging_name"] = "bar"
url.query.pop("myplugin_arg", None)
return MyEnginePlugin
MyEnginePlugin = Mock(side_effect=side_effect)
plugins.register("engineplugin", __name__, "MyEnginePlugin")
e = create_engine(
"sqlite:///?plugin=engineplugin&foo=bar&myplugin_arg=bat",
logging_name="foob",
)
eq_(e.dialect.name, "sqlite")
eq_(e.logging_name, "bar")
# plugin args are removed from URL.
eq_(e.url.query, {"foo": "bar"})
assert isinstance(e.dialect, sqlite.dialect)
eq_(
MyEnginePlugin.mock_calls,
[
call(url.make_url("sqlite:///?foo=bar"), {}),
call.handle_dialect_kwargs(sqlite.dialect, mock.ANY),
call.handle_pool_kwargs(mock.ANY, {"dialect": e.dialect}),
call.engine_created(e),
],
)
# url was modified in place by MyEnginePlugin
eq_(str(MyEnginePlugin.mock_calls[0][1][0]), "sqlite:///?foo=bar")
def test_urlattr(self):
"""test the url attribute on ``Engine``."""
e = create_engine(
"mysql://*****:*****@localhost/test",
module=mock_dbapi,
_initialize=False,
)
u = url.make_url("mysql://*****:*****@localhost/test")
e2 = create_engine(u, module=mock_dbapi, _initialize=False)
assert e.url.drivername == e2.url.drivername == "mysql"
assert e.url.username == e2.url.username == "scott"
assert e2.url is u
assert str(u) == "mysql://*****:*****@localhost/test"
assert repr(u) == "mysql://*****:*****@localhost/test"
assert repr(e) == "Engine(mysql://scott:***@localhost/test)"
assert repr(e2) == "Engine(mysql://scott:***@localhost/test)"
def test_plugin_arg_registration(self):
from sqlalchemy_1_3.dialects import sqlite
global MyEnginePlugin
def side_effect(url, kw):
eq_(
kw,
{
"logging_name": "foob",
"plugins": ["engineplugin"],
"myplugin_arg": "bat",
},
)
kw["logging_name"] = "bar"
kw.pop("myplugin_arg", None)
return MyEnginePlugin
MyEnginePlugin = Mock(side_effect=side_effect)
plugins.register("engineplugin", __name__, "MyEnginePlugin")
e = create_engine(
"sqlite:///?foo=bar",
logging_name="foob",
plugins=["engineplugin"],
myplugin_arg="bat",
)
eq_(e.dialect.name, "sqlite")
eq_(e.logging_name, "bar")
assert isinstance(e.dialect, sqlite.dialect)
eq_(
MyEnginePlugin.mock_calls,
[
call(url.make_url("sqlite:///?foo=bar"), {}),
call.handle_dialect_kwargs(sqlite.dialect, mock.ANY),
call.handle_pool_kwargs(mock.ANY, {"dialect": e.dialect}),
call.engine_created(e),
],
)
def testing_engine(url=None, options=None):
"""Produce an engine configured by --options with optional overrides."""
from sqlalchemy_1_3 import create_engine
from sqlalchemy_1_3.engine.url import make_url
if not options:
use_reaper = True
else:
use_reaper = options.pop("use_reaper", True)
url = url or config.db.url
url = make_url(url)
if options is None:
if config.db is None or url.drivername == config.db.url.drivername:
options = config.db_opts
else:
options = {}
elif config.db is not None and url.drivername == config.db.url.drivername:
default_opt = config.db_opts.copy()
default_opt.update(options)
engine = create_engine(url, **options)
engine._has_events = True # enable event blocks, helps with profiling
if isinstance(engine.pool, pool.QueuePool):
engine.pool._timeout = 0
engine.pool._max_overflow = 0
if use_reaper:
event.listen(engine.pool, "connect", testing_reaper.connect)
event.listen(engine.pool, "checkout", testing_reaper.checkout)
event.listen(engine.pool, "invalidate", testing_reaper.invalidate)
testing_reaper.add_engine(engine)
return engine
def test_psycopg2_nonempty_connection_string_w_query(self):
dialect = psycopg2_dialect.dialect()
u = url.make_url("postgresql://somehost/?any_random_thing=yes")
cargs, cparams = dialect.create_connect_args(u)
eq_(cargs, [])
eq_(cparams, {"host": "somehost", "any_random_thing": "yes"})
def test_random_arg(self):
dialect = testing.db.dialect
kw = dialect.create_connect_args(
make_url("mysql://*****:*****@host/db?foo=true")
)[1]
eq_(kw["foo"], "true")
def test_psycopg2_nonempty_connection_string(self):
dialect = psycopg2_dialect.dialect()
u = url.make_url("postgresql://host")
cargs, cparams = dialect.create_connect_args(u)
eq_(cargs, [])
eq_(cparams, {"host": "host"})
def test_psycopg2_empty_connection_string_w_query_one(self):
dialect = psycopg2_dialect.dialect()
u = url.make_url("postgresql:///?service=swh-log")
cargs, cparams = dialect.create_connect_args(u)
eq_(cargs, [])
eq_(cparams, {"service": "swh-log"})
