become an externally usable package but still remains within the main sqlalchemy parent package.
in this system, we use kind of an ugly hack to get the noseplugin imported outside of the
"sqlalchemy" package, while still making it available within sqlalchemy for usage by
third party libraries.
from .warnings import testing_warn, assert_warnings, resetwarnings
-from ..bootstrap import config
-from . import assertsql, util as testutil
-from sqlalchemy.util import decorator
+from . import config
from .exclusions import db_spec, _is_excluded, fails_if, skip_if, future,\
fails_on, fails_on_everything_except, skip, only_on, exclude, against,\
crashes = skip
-# various sugar installed by config.py
-db = None
-requires = None
+from .config import db, requirements as requires
from .warnings import resetwarnings
from .exclusions import db_spec, _is_excluded
from . import assertsql
-from ..bootstrap import config
+from . import config
import itertools
from .util import fail
--- /dev/null
+requirements = None
+db = None
+
import types
import weakref
from collections import deque
-from ..bootstrap import config
+from . import config
from .util import decorator
from sqlalchemy import event, pool
import re
self._stop_test_ctx_aggressive()
def _stop_test_ctx_minimal(self):
- from test.lib import testing
self.close_all()
self.conns = set()
for rec in self.testing_engines.keys():
- if rec is not testing.db:
+ if rec is not config.db:
rec.dispose()
def _stop_test_ctx_aggressive(self):
"""Produce an engine configured by --options with optional overrides."""
from sqlalchemy import create_engine
- from test.lib.assertsql import asserter
+ from .assertsql import asserter
if not options:
use_reaper = True
use_reaper = options.pop('use_reaper', True)
url = url or config.db_url
- options = options or config.db_opts
+ if options is None:
+ options = config.db_opts
engine = create_engine(url, **options)
if isinstance(engine.pool, pool.QueuePool):
import operator
from nose import SkipTest
from sqlalchemy.util import decorator
-from ..bootstrap import config
+from . import config
from sqlalchemy import util
if self.op is not None:
assert driver is None, "DBAPI version specs not supported yet"
- version = _server_version()
+ version = _server_version(engine)
oper = hasattr(self.op, '__call__') and self.op \
or self._ops[self.op]
return oper(version, self.spec)
def _is_excluded(db, op, spec):
return SpecPredicate(db, op, spec)()
-def _server_version(bind=None):
+def _server_version(engine):
"""Return a server_version_info tuple."""
- if bind is None:
- bind = config.db
-
# force metadata to be retrieved
- conn = bind.connect()
- version = getattr(bind.dialect, 'server_version_info', ())
+ conn = engine.connect()
+ version = getattr(engine.dialect, 'server_version_info', ())
conn.close()
return version
Predicate.as_predicate(db) for db in dbs
)
+def open(fn):
+ return fn
+
@decorator
def future(fn, *args, **kw):
return fails_if(LambdaPredicate(fn, *args, **kw), "Future feature")
-from ..bootstrap import config
+from . import config
from . import assertions, schema
from .util import adict
from .engines import drop_all_tables
def _setup_options(opt, file_config):
global options
- options = opt
+ from sqlalchemy.testing import config
+ config.options = options = opt
pre_configure.append(_setup_options)
def _monkeypatch_cdecimal(options, file_config):
post_configure.append(_engine_pool)
def _create_testing_engine(options, file_config):
- from test.lib import engines, testing
+ from sqlalchemy.testing import engines, config
+ from sqlalchemy import testing
global db
- db = engines.testing_engine(db_url, db_opts)
- testing.db = db
+ config.db = testing.db = db = engines.testing_engine(db_url, db_opts)
+ config.db_opts = db_opts
+ config.db_url = db_url
+
post_configure.append(_create_testing_engine)
def _prep_testing_database(options, file_config):
- from test.lib import engines
+ from sqlalchemy.testing import engines
from sqlalchemy import schema
# also create alt schemas etc. here?
post_configure.append(_prep_testing_database)
def _set_table_options(options, file_config):
- from test.lib import schema
+ from sqlalchemy.testing import schema
table_options = schema.table_options
for spec in options.tableopts:
if options.reversetop:
from sqlalchemy.orm import unitofwork, session, mapper, dependency
from sqlalchemy.util import topological
- from test.lib.util import RandomSet
+ from sqlalchemy.testing.util import RandomSet
topological.set = unitofwork.set = session.set = mapper.set = \
dependency.set = RandomSet
post_configure.append(_reverse_topological)
def _requirements(options, file_config):
- from ..lib import testing
+ from sqlalchemy.testing import config
+ from sqlalchemy import testing
requirement_cls = file_config.get('sqla_testing', "requirement_cls")
modname, clsname = requirement_cls.split(":")
mod = __import__(modname)
for component in modname.split(".")[1:]:
mod = getattr(mod, component)
-
req_cls = getattr(mod, clsname)
- global requirements
- requirements = req_cls(db, sys.modules[__name__])
- testing.requires = requirements
+ config.requirements = testing.requires = req_cls(db, config)
post_configure.append(_requirements)
-
def _setup_profiling(options, file_config):
- from ..lib import profiling
+ from sqlalchemy.testing import profiling
profiling._profile_stats = profiling.ProfileStatsFile(
file_config.get('sqla_testing', 'profile_file'))
-post_configure.append(_setup_profiling)
\ No newline at end of file
+post_configure.append(_setup_profiling)
+
+"""Enhance nose with extra options and behaviors for running SQLAlchemy tests.
+
+This module is imported relative to the "plugins" package as a top level
+package by the sqla_nose.py runner, so that the plugin can be loaded with
+the rest of nose including the coverage plugin before any of SQLAlchemy itself
+is imported, so that coverage works.
+
+When third party libraries use this library, it can be imported
+normally as "from sqlalchemy.testing.plugin import noseplugin".
+
+"""
import os
import ConfigParser
post_configure
# late imports
-testing = None
fixtures = None
engines = None
exclusions = None
warnings = None
profiling = None
assertions = None
-requires = None
+requirements = None
util = None
file_config = None
"""
enabled = True
- # nose 1.0 will allow us to replace the old "sqlalchemy" plugin,
- # if installed, using the same name, but nose 1.0 isn't released yet...
- name = 'sqlalchemy'
+ name = 'sqla_testing'
score = 100
def options(self, parser, env=os.environ):
# late imports, has to happen after config as well
# as nose plugins like coverage
- global testing, requires, util, fixtures, engines, exclusions, \
+ global util, fixtures, engines, exclusions, \
assertions, warnings, profiling
- from test.lib import testing, requires, fixtures, engines, exclusions, \
+ from sqlalchemy.testing import fixtures, engines, exclusions, \
assertions, warnings, profiling
from sqlalchemy import util
return True
def _do_skips(self, cls):
+ from sqlalchemy.testing import config
if hasattr(cls, '__requires__'):
def test_suite():
return 'ok'
exclusions.exclude(db, op, spec,
"'%s' unsupported on DB %s version %s" % (
cls.__name__, config.db.name,
- exclusions._server_version()))
+ exclusions._server_version(config.db)))
def beforeTest(self, test):
warnings.resetwarnings()
import os
import sys
from .util import gc_collect, decorator
-from ..bootstrap import config
+from . import config
from nose import SkipTest
import pstats
import time
"" % (self.fname)
def _read(self):
- profile_f = open(self.fname)
+ try:
+ profile_f = open(self.fname)
+ except IOError:
+ return
for lineno, line in enumerate(profile_f):
line = line.strip()
if not line or line.startswith("#"):
--- /dev/null
+"""Global database feature support policy.
+
+Provides decorators to mark tests requiring specific feature support from the
+target database.
+
+"""
+
+from .exclusions import \
+ skip, \
+ skip_if,\
+ only_if,\
+ only_on,\
+ fails_on,\
+ fails_on_everything_except,\
+ fails_if,\
+ SpecPredicate,\
+ against
+
+def no_support(db, reason):
+ return SpecPredicate(db, description=reason)
+
+def exclude(db, op, spec, description=None):
+ return SpecPredicate(db, op, spec, description=description)
+
+
+def _chain_decorators_on(*decorators):
+ def decorate(fn):
+ for decorator in reversed(decorators):
+ fn = decorator(fn)
+ return fn
+ return decorate
+
+class Requirements(object):
+ def __init__(self, db, config):
+ self.db = db
+ self.config = config
+
+
from . import exclusions
from sqlalchemy import schema, event
-from ..bootstrap import config
+from . import config
__all__ = 'Table', 'Column',
--- /dev/null
+from ..requirements import Requirements
+from .. import exclusions
+
+
+class SuiteRequirements(Requirements):
+
+ @property
+ def create_table(self):
+ """target platform can emit basic CreateTable DDL."""
+
+ return exclusions.open
+
+ @property
+ def drop_table(self):
+ """target platform can emit basic DropTable DDL."""
+
+ return exclusions.open
+
+ @property
+ def autoincrement_insert(self):
+ """target platform generates new surrogate integer primary key values
+ when insert() is executed, excluding the pk column."""
+
+ return exclusions.open
--- /dev/null
+from .. import fixtures, config, util
+from ..config import requirements
+from ..assertions import eq_
+
+from sqlalchemy import Table, Column, Integer, String
+
+
+class TableDDLTest(fixtures.TestBase):
+
+ def _simple_fixture(self):
+ return Table('test_table', self.metadata,
+ Column('id', Integer, primary_key=True),
+ Column('data', String(50))
+ )
+
+ def _simple_roundtrip(self):
+ with config.db.begin() as conn:
+ conn.execute("insert into test_table(id, data) values "
+ "(1, 'some data')")
+ result = conn.execute("select id, data from test_table")
+ eq_(
+ result.first(),
+ (1, 'some data')
+ )
+
+
+ @requirements.create_table
+ @util.provide_metadata
+ def test_create_table(self):
+ table = self._simple_fixture()
+ table.create(
+ config.db, checkfirst=False
+ )
+ self._simple_roundtrip()
+
+
+ @requirements.drop_table
+ @util.provide_metadata
+ def test_drop_table(self):
+ table = self._simple_fixture()
+ table.create(
+ config.db, checkfirst=False
+ )
+ table.drop(
+ config.db, checkfirst=False
+ )
+
+__all__ = ('TableDDLTest',)
\ No newline at end of file
--- /dev/null
+from .. import fixtures, config, util
+from ..config import requirements
+from ..assertions import eq_
+
+from sqlalchemy import Table, Column, Integer, String
+
+
+class InsertSequencingTest(fixtures.TablesTest):
+ run_deletes = 'each'
+
+ @classmethod
+ def define_tables(cls, metadata):
+ Table('plain_pk', metadata,
+ Column('id', Integer, primary_key=True),
+ Column('data', String(50))
+ )
+
+ def _assert_round_trip(self, table):
+ row = config.db.execute(table.select()).first()
+ eq_(
+ row,
+ (1, "some data")
+ )
+
+ @requirements.autoincrement_insert
+ def test_autoincrement_on_insert(self):
+
+ config.db.execute(
+ self.tables.plain_pk.insert(),
+ data="some data"
+ )
+ self._assert_round_trip(self.tables.plain_pk)
+
+
+
+__all__ = ('InsertSequencingTest',)
\ No newline at end of file
def provide_metadata(fn, *args, **kw):
"""Provide bound MetaData for a single test, dropping afterwards."""
- from ..bootstrap.config import db
+ from . import config
from sqlalchemy import schema
- metadata = schema.MetaData(db)
+ metadata = schema.MetaData(config.db)
self = args[0]
prev_meta = getattr(self, 'metadata', None)
self.metadata = metadata
def testing_warn(msg, stacklevel=3):
"""Replaces sqlalchemy.util.warn during tests."""
- filename = "test.lib.testing"
+ filename = "sqlalchemy.testing.warnings"
lineno = 1
if isinstance(msg, basestring):
warnings.warn_explicit(msg, sa_exc.SAWarning, filename, lineno)
tag_build = dev
[nosetests]
-with-sqlalchemy = true
+with-sqla_testing = true
exclude = ^examples
first-package-wins = true
where = test
[sqla_testing]
-requirement_cls=test.lib.requires:DefaultRequirements
-profile_file=test/lib/profiles.txt
+requirement_cls=test.requirements:DefaultRequirements
+profile_file=test/profiles.txt
[db]
sqlite=sqlite:///:memory:
import sys
from os import path
-for pth in ['.', './lib']:
+for pth in ['.', './lib', './lib/sqlalchemy/testing']:
sys.path.insert(0, path.join(path.dirname(path.abspath(__file__)), pth))
-from test.bootstrap.noseplugin import NoseSQLAlchemy
+
+from plugin.noseplugin import NoseSQLAlchemy
import nose
from sqlalchemy import *
-from test.lib import *
+from sqlalchemy.testing import *
from sqlalchemy.engine import default
class CompileTest(fixtures.TestBase, AssertsExecutionResults):
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy.orm import mapper, relationship, create_session, \
clear_mappers, sessionmaker, class_mapper, aliased,\
Session, subqueryload
from sqlalchemy.orm.mapper import _mapper_registry
from sqlalchemy.orm.session import _sessions
import operator
-from test.lib import testing, engines
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
from sqlalchemy import MetaData, Integer, String, ForeignKey, \
PickleType, create_engine, Unicode
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
import sqlalchemy as sa
from sqlalchemy.sql import column
from sqlalchemy.processors import to_decimal_processor_factory, \
to_unicode_processor_factory
-from test.lib.util import gc_collect
+from sqlalchemy.testing.util import gc_collect
from sqlalchemy.util.compat import decimal
import gc
import weakref
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class A(fixtures.ComparableEntity):
pass
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message
from sqlalchemy import exc as sa_exc, util, Integer, String, ForeignKey
from sqlalchemy.orm import exc as orm_exc, mapper, relationship, \
sessionmaker, Session
-from test.lib import testing, profiling
-from test.lib import fixtures
-from test.lib.schema import Table, Column
+from sqlalchemy import testing
+from sqlalchemy.testing import profiling
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Table, Column
import sys
class MergeTest(fixtures.MappedTest):
from sqlalchemy import *
-from test.lib import *
+from sqlalchemy.testing import *
from sqlalchemy.pool import QueuePool
from sqlalchemy import pool as pool_module
from sqlalchemy import *
-from test.lib import *
-from test.lib.testing import eq_
+from sqlalchemy.testing import *
+from sqlalchemy.testing import eq_
NUM_FIELDS = 10
NUM_RECORDS = 1000
import sys
import time
from sqlalchemy import *
-from test.lib import *
+from sqlalchemy.testing import *
ITERATIONS = 1
dbapi_session = engines.ReplayableSession()
metadata = None
import time
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import *
+from sqlalchemy.testing import *
ITERATIONS = 1
dbapi_session = engines.ReplayableSession()
metadata = None
from sqlalchemy.util import topological
-from test.lib.testing import assert_raises, eq_
-from test.lib.util import conforms_partial_ordering
+from sqlalchemy.testing import assert_raises, eq_
+from sqlalchemy.testing.util import conforms_partial_ordering
from sqlalchemy import exc
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class DependencySortTest(fixtures.TestBase):
"""Test event registration and listening."""
-from test.lib.testing import eq_, assert_raises, assert_raises_message, \
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message, \
is_, is_not_
from sqlalchemy import event, exc, util
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class EventsTest(fixtures.TestBase):
"""Test class- and instance-level event registration."""
from sqlalchemy import exc as sa_exceptions
-from test.lib import fixtures
-from test.lib.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import eq_
# Py3K
#StandardError = BaseException
"""test the inspection registry system."""
-from test.lib.testing import eq_, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises_message
from sqlalchemy import exc, util
from sqlalchemy import inspection, inspect
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class TestFixture(object):
pass
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import copy, threading
from sqlalchemy import util, sql, exc
-from test.lib.testing import eq_, is_, ne_, fails_if
-from test.lib.util import gc_collect, picklers
+from sqlalchemy.testing import eq_, is_, ne_, fails_if
+from sqlalchemy.testing.util import gc_collect, picklers
from sqlalchemy.util import classproperty
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class OrderedDictTest(fixtures.TestBase):
def test_odict(self):
from sqlalchemy import *
from sqlalchemy import sql
from sqlalchemy.databases import access
-from test.lib import *
+from sqlalchemy.testing import *
class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
-from test.lib.testing import eq_, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises_message
from sqlalchemy import exc
from sqlalchemy.databases import firebird
from sqlalchemy.exc import ProgrammingError
from sqlalchemy.sql import table, column
from sqlalchemy import types as sqltypes
-from test.lib import fixtures, AssertsExecutionResults, AssertsCompiledSQL
-from test.lib import testing, engines
+from sqlalchemy.testing import fixtures, AssertsExecutionResults, AssertsCompiledSQL
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
from sqlalchemy import String, VARCHAR, NVARCHAR, Unicode, Integer,\
func, insert, update, MetaData, select, Table, Column, text,\
Sequence, Float
from sqlalchemy import *
from sqlalchemy.databases import informix
-from test.lib import *
+from sqlalchemy.testing import *
class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
"""MaxDB-specific tests."""
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
import StringIO, sys
from sqlalchemy import *
from sqlalchemy import exc, sql
from sqlalchemy.util.compat import decimal
from sqlalchemy.databases import maxdb
-from test.lib import *
+from sqlalchemy.testing import *
# TODO
# -*- encoding: utf-8
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
import datetime
import os
import re
from sqlalchemy.dialects.mssql import pyodbc, mxodbc, pymssql
from sqlalchemy.dialects.mssql.base import TIME
from sqlalchemy.engine import url
-from test.lib import *
-from test.lib.testing import eq_, emits_warning_on, \
+from sqlalchemy.testing import *
+from sqlalchemy.testing import eq_, emits_warning_on, \
assert_raises_message
from sqlalchemy.util.compat import decimal
from sqlalchemy.engine.reflection import Inspector
finally:
meta.drop_all()
-from test.lib.assertsql import ExactSQL
+from sqlalchemy.testing.assertsql import ExactSQL
class QueryTest(testing.AssertsExecutionResults, fixtures.TestBase):
__only_on__ = 'mssql'
from sqlalchemy import *
-from test.lib.testing import eq_
-from test.lib import engines
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import fixtures
# TODO: we should probably build mock bases for
# these to share with test_reconnect, test_parseconnect
# coding: utf-8
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
from sqlalchemy import *
from sqlalchemy import sql, exc, schema, types as sqltypes
from sqlalchemy.dialects.mysql import base as mysql
from sqlalchemy.engine.url import make_url
-from test.lib import fixtures, AssertsCompiledSQL, AssertsExecutionResults
-from test.lib import testing, engines
-from test.lib.engines import utf8_engine
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL, AssertsExecutionResults
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
+from sqlalchemy.testing.engines import utf8_engine
import datetime
class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
# coding: utf-8
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy import *
from sqlalchemy import types as sqltypes, exc
from sqlalchemy.sql import table, column
-from test.lib import *
-from test.lib.testing import eq_, assert_raises, assert_raises_message
-from test.lib.engines import testing_engine
+from sqlalchemy.testing import *
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing.engines import testing_engine
from sqlalchemy.dialects.oracle import cx_oracle, base as oracle
from sqlalchemy.engine import default
from sqlalchemy.util import jython
from __future__ import with_statement
-from test.lib.testing import eq_, assert_raises, assert_raises_message, is_
-from test.lib import engines
+from sqlalchemy.testing.assertions import eq_, assert_raises, \
+ assert_raises_message, is_, AssertsExecutionResults, \
+ AssertsCompiledSQL, ComparesTables
+from sqlalchemy.testing import engines, fixtures
+from sqlalchemy import testing
import datetime
-from sqlalchemy import *
-from sqlalchemy.orm import *
+from sqlalchemy import Table, Column, select, MetaData, text, Integer, \
+ String, Sequence, ForeignKey, join, Numeric, \
+ PrimaryKeyConstraint, DateTime, tuple_, Float, BigInteger, \
+ func, literal_column, literal, bindparam, cast, extract, \
+ SmallInteger, Enum, REAL, update, insert, Index, delete, \
+ and_, Date, TypeDecorator, Time, Unicode, Interval
+from sqlalchemy.orm import Session, mapper, aliased
from sqlalchemy import exc, schema, types
from sqlalchemy.dialects.postgresql import base as postgresql
-from sqlalchemy.engine.strategies import MockEngineStrategy
from sqlalchemy.util.compat import decimal
-from test.lib import *
-from test.lib.util import round_decimal
+from sqlalchemy.testing.util import round_decimal
from sqlalchemy.sql import table, column
-from test.lib.testing import eq_
import logging
class SequenceTest(fixtures.TestBase, AssertsCompiledSQL):
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy.connectors import pyodbc
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class PyODBCTest(fixtures.TestBase):
def test_pyodbc_version(self):
"""SQLite-specific tests."""
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message
import datetime
from sqlalchemy import *
from sqlalchemy.dialects.sqlite import base as sqlite, \
pysqlite as pysqlite_dialect
from sqlalchemy.engine.url import make_url
-from test.lib import *
+from sqlalchemy.testing import *
import os
from sqlalchemy.schema import CreateTable
--- /dev/null
+from sqlalchemy.testing.suite.test_ddl import *
+from sqlalchemy.testing.suite.test_sequencing import *
+
+
+
+
+
+
from sqlalchemy import *
from sqlalchemy import sql
from sqlalchemy.databases import sybase
-from test.lib import *
+from sqlalchemy.testing import *
class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
"""tests the "bind" attribute/argument across schema and SQL,
including the deprecated versions of these arguments"""
-from test.lib.testing import eq_, assert_raises
+from sqlalchemy.testing import eq_, assert_raises
from sqlalchemy import engine, exc
from sqlalchemy import MetaData, ThreadLocalMetaData
from sqlalchemy import Integer, text
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
import sqlalchemy as sa
-from test.lib import testing
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
class BindTest(fixtures.TestBase):
def test_create_drop_explicit(self):
from __future__ import with_statement
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy.schema import DDL, CheckConstraint, AddConstraint, \
DropConstraint
from sqlalchemy import create_engine
from sqlalchemy import MetaData, Integer, String, event, exc, text
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
import sqlalchemy as tsa
-from test.lib import testing, engines
-from test.lib.testing import AssertsCompiledSQL, eq_
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import AssertsCompiledSQL, eq_
from nose import SkipTest
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class DDLEventTest(fixtures.TestBase):
# We're abusing the DDL()
# construct here by pushing a SELECT through it
- # so that we can verify the round trip.
+ # so that we can verify the round trip.
# the DDL() will trigger autocommit, which prohibits
# some DBAPIs from returning results (pyodbc), so we
- # run in an explicit transaction.
+ # run in an explicit transaction.
with testing.db.begin() as conn:
eq_(
conn.execute(
from __future__ import with_statement
-from test.lib.testing import eq_, assert_raises, assert_raises_message, \
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message, \
config, is_
import re
-from test.lib.util import picklers
+from sqlalchemy.testing.util import picklers
from sqlalchemy.interfaces import ConnectionProxy
from sqlalchemy import MetaData, Integer, String, INT, VARCHAR, func, \
bindparam, select, event, TypeDecorator, create_engine, Sequence
from sqlalchemy.sql import column, literal
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
import sqlalchemy as tsa
-from test.lib import testing, engines
-from test.lib.engines import testing_engine
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
+from sqlalchemy.testing.engines import testing_engine
import logging
from sqlalchemy.dialects.oracle.zxjdbc import ReturningParam
from sqlalchemy.engine import result as _result, default
from sqlalchemy.engine.base import Connection, Engine
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
import StringIO
users, metadata, users_autoinc = None, None, None
-from test.lib.testing import assert_raises, assert_raises_message, eq_
+from sqlalchemy.testing import assert_raises, assert_raises_message, eq_
import ConfigParser
import StringIO
import sqlalchemy.engine.url as url
from sqlalchemy.engine.util import _coerce_config
from sqlalchemy.engine.default import DefaultDialect
import sqlalchemy as tsa
-from test.lib import fixtures, testing
+from sqlalchemy.testing import fixtures
+from sqlalchemy import testing
class ParseConnectTest(fixtures.TestBase):
def test_rfc1738(self):
import threading, time
from sqlalchemy import pool, interfaces, select, event
import sqlalchemy as tsa
-from test.lib import testing
-from test.lib.util import gc_collect, lazy_gc
-from test.lib.testing import eq_, assert_raises
-from test.lib.engines import testing_engine
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing.util import gc_collect, lazy_gc
+from sqlalchemy.testing import eq_, assert_raises
+from sqlalchemy.testing.engines import testing_engine
+from sqlalchemy.testing import fixtures
mcid = 1
class MockDBAPI(object):
-from test.lib import fixtures
-from test.lib.testing import assert_raises_message, eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import assert_raises_message, eq_
class _DateProcessorTest(fixtures.TestBase):
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
import time
import weakref
from sqlalchemy import select, MetaData, Integer, String, pool, create_engine
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
import sqlalchemy as tsa
-from test.lib import testing, engines
-from test.lib.util import gc_collect
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
+from sqlalchemy.testing.util import gc_collect
from sqlalchemy import exc
-from test.lib import fixtures
-from test.lib.engines import testing_engine
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.engines import testing_engine
class MockDisconnect(Exception):
pass
from sqlalchemy import schema, events, event, inspect
from sqlalchemy import MetaData, Integer, String
from sqlalchemy.engine.reflection import Inspector
-from test.lib import ComparesTables, \
- testing, engines, AssertsCompiledSQL, fixtures
-from test.lib.schema import Table, Column
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import ComparesTables, \
+ engines, AssertsCompiledSQL, fixtures
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy import testing
metadata, users = None, None
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message, ne_
import sys
import time
import threading
-from test.lib.engines import testing_engine
+from sqlalchemy.testing.engines import testing_engine
from sqlalchemy import create_engine, MetaData, INT, VARCHAR, Sequence, \
select, Integer, String, func, text, exc
-from test.lib.schema import Table
-from test.lib.schema import Column
-from test.lib import testing
-from test.lib import fixtures
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
users, metadata = None, None
-from test.lib import *
+from sqlalchemy.testing import *
import os
import re
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message, is_
from sqlalchemy.ext import declarative as decl
from sqlalchemy import exc
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import MetaData, Integer, String, ForeignKey, \
ForeignKeyConstraint, Index
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import relationship, create_session, class_mapper, \
joinedload, configure_mappers, backref, clear_mappers, \
deferred, column_property, composite,\
Session
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy.util import classproperty
from sqlalchemy.ext.declarative import declared_attr, AbstractConcreteBase, ConcreteBase
-from test.lib import fixtures
-from test.lib.util import gc_collect
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.util import gc_collect
Base = None
-from test.lib import fixtures
-from test.lib.util import gc_collect
-from test.lib.testing import assert_raises_message, is_, eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.util import gc_collect
+from sqlalchemy.testing import assert_raises_message, is_, eq_
from sqlalchemy import exc, MetaData
from sqlalchemy.ext.declarative import clsregistry
import weakref
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message, is_
from sqlalchemy.ext import declarative as decl
from sqlalchemy import exc
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import MetaData, Integer, String, ForeignKey, \
ForeignKeyConstraint, Index
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import relationship, create_session, class_mapper, \
joinedload, configure_mappers, backref, clear_mappers, \
polymorphic_union, deferred, column_property, composite,\
Session
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy.util import classproperty
from sqlalchemy.ext.declarative import declared_attr, AbstractConcreteBase, ConcreteBase
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
Base = None
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message, is_
from sqlalchemy.ext import declarative as decl
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import relationship, create_session, class_mapper, \
configure_mappers, clear_mappers, \
deferred, column_property, \
Session
from sqlalchemy.util import classproperty
from sqlalchemy.ext.declarative import declared_attr
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
Base = None
-from test.lib.testing import eq_, assert_raises
+from sqlalchemy.testing import eq_, assert_raises
from sqlalchemy.ext import declarative as decl
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import MetaData, Integer, String, ForeignKey
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import relationship, create_session, \
clear_mappers, \
Session
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class DeclarativeReflectionBase(fixtures.TablesTest):
__requires__ = 'reflectable_autoincrement',
-from test.lib.testing import eq_, assert_raises
+from sqlalchemy.testing import eq_, assert_raises
import copy
import pickle
from sqlalchemy.orm.collections import collection, attribute_mapped_collection
from sqlalchemy.ext.associationproxy import *
from sqlalchemy.ext.associationproxy import _AssociationList
-from test.lib import *
-from test.lib.testing import assert_raises_message
-from test.lib.util import gc_collect
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing.util import gc_collect
from sqlalchemy.sql import not_
-from test.lib import fixtures
-
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL
+from sqlalchemy import testing
+from sqlalchemy.testing.schema import Table, Column
class DictCollection(dict):
@collection.appender
from sqlalchemy.ext.compiler import compiles, deregister
from sqlalchemy import exc
from sqlalchemy.sql import table, column, visitors
-from test.lib.testing import assert_raises_message
-from test.lib import *
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL
class UserDefinedTest(fixtures.TestBase, AssertsCompiledSQL):
__dialect__ = 'default'
-from test.lib.testing import eq_, assert_raises, assert_raises_message, ne_
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message, ne_
from sqlalchemy import util
from sqlalchemy.orm import attributes
from sqlalchemy.orm.attributes import set_attribute, get_attribute, del_attribute
from sqlalchemy.orm.instrumentation import is_instrumented
from sqlalchemy.orm import clear_mappers
-from test.lib import *
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
from sqlalchemy.ext import instrumentation
from sqlalchemy.orm.instrumentation import register_class
-from test.lib.util import decorator
+from sqlalchemy.testing.util import decorator
from sqlalchemy.orm import events
from sqlalchemy import event
from sqlalchemy.orm import *
from sqlalchemy.ext.horizontal_shard import ShardedSession
from sqlalchemy.sql import operators
-from test.lib import *
-from test.lib.engines import testing_engine
-from test.lib.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing.engines import testing_engine
+from sqlalchemy.testing import eq_
from nose import SkipTest
# TODO: ShardTest can be turned into a base for further subclasses
from sqlalchemy import func, Integer, String, ForeignKey
from sqlalchemy.orm import relationship, Session, aliased
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Column
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext import hybrid
-from test.lib.testing import eq_, AssertsCompiledSQL, assert_raises_message
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, AssertsCompiledSQL, assert_raises_message
+from sqlalchemy.testing import fixtures
class PropertyComparatorTest(fixtures.TestBase, AssertsCompiledSQL):
__dialect__ = 'default'
from sqlalchemy.orm import mapper, Session, composite
from sqlalchemy.orm.mapper import Mapper
from sqlalchemy.orm.instrumentation import ClassManager
-from test.lib.schema import Table, Column
-from test.lib.testing import eq_, assert_raises_message
-from test.lib.util import picklers
-from test.lib import testing
-from test.lib import fixtures
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import eq_, assert_raises_message
+from sqlalchemy.testing.util import picklers
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
import sys
import pickle
from sqlalchemy import Integer, ForeignKey, String, MetaData
from sqlalchemy.orm import relationship, mapper, create_session
from sqlalchemy.ext.orderinglist import ordering_list
-from test.lib.testing import eq_
-from test.lib import fixtures, testing
-from test.lib.schema import Table, Column
-from test.lib.util import picklers
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing.util import picklers
metadata = None
from sqlalchemy.ext import serializer
from sqlalchemy import exc
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import MetaData, Integer, String, ForeignKey, select, \
desc, func, util
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import relationship, sessionmaker, scoped_session, \
class_mapper, mapper, joinedload, configure_mappers, aliased
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class User(fixtures.ComparableEntity):
pass
+++ /dev/null
-"""Testing environment and utilities.
-
-"""
-
-from ..bootstrap import config
-from . import testing, engines, requires, profiling, pickleable, \
- fixtures
-from .schema import Column, Table
-from .assertions import AssertsCompiledSQL, \
- AssertsExecutionResults, ComparesTables
-from .util import rowset
-
-
-__all__ = ('testing',
- 'Column', 'Table',
- 'rowset',
- 'fixtures',
- 'AssertsExecutionResults',
- 'AssertsCompiledSQL', 'ComparesTables',
- 'engines', 'profiling', 'pickleable')
-
-
from sqlalchemy import MetaData, Integer, String, ForeignKey
from sqlalchemy import util
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import attributes, mapper, relationship, \
backref, configure_mappers
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
__all__ = ()
from sqlalchemy import exc as sa_exc
from sqlalchemy.engine import default
-from test.lib import AssertsCompiledSQL, fixtures, testing
-from test.lib.schema import Table, Column
-from test.lib.testing import assert_raises, eq_
+from sqlalchemy.testing import AssertsCompiledSQL, fixtures, testing
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import assert_raises, eq_
class Company(fixtures.ComparableEntity):
pass
from sqlalchemy.orm import *
from sqlalchemy.orm.interfaces import ONETOMANY, MANYTOONE
-from test.lib import testing
-from test.lib.schema import Table, Column
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import fixtures
def produce_test(parent, child, direction):
from sqlalchemy import util
from sqlalchemy.orm import *
-from test.lib.util import function_named
-from test.lib import fixtures
+from sqlalchemy.testing.util import function_named
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib.testing import eq_
-from test.lib.schema import Table, Column
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing.schema import Table, Column
class ABCTest(fixtures.MappedTest):
@classmethod
"""
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy import *
from sqlalchemy import util
from sqlalchemy.orm import *
from sqlalchemy.orm.interfaces import MANYTOONE
-from test.lib import AssertsExecutionResults, testing
-from test.lib.util import function_named
-from test.lib import fixtures
+from sqlalchemy.testing import AssertsExecutionResults, testing
+from sqlalchemy.testing.util import function_named
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib.testing import eq_
-from test.lib.schema import Table, Column
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing.schema import Table, Column
class AttrSettable(object):
def __init__(self, **kwargs):
import warnings
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
from sqlalchemy import *
from sqlalchemy import exc as sa_exc, util, event
from sqlalchemy.orm import *
from sqlalchemy.orm import exc as orm_exc, attributes
-from test.lib.assertsql import AllOf, CompiledSQL
+from sqlalchemy.testing.assertsql import AllOf, CompiledSQL
from sqlalchemy.sql import table, column
-from test.lib import testing, engines
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy import inspect
from sqlalchemy.ext.declarative import declarative_base
-from test.lib.util import gc_collect
+from sqlalchemy.testing.util import gc_collect
class O2MTest(fixtures.MappedTest):
"""deals with inheritance and one-to-many relationships"""
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message
from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.orm import exc as orm_exc
-from test.lib import *
+from sqlalchemy.testing import *
import sqlalchemy as sa
-from test.lib import testing
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
from sqlalchemy.orm import attributes
-from test.lib.testing import eq_
-from test.lib.schema import Table, Column
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing.schema import Table, Column
class Employee(object):
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import testing
-from test.lib.util import function_named
-from test.lib import fixtures
-from test.lib.schema import Table, Column
+from sqlalchemy import testing
+from sqlalchemy.testing.util import function_named
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Table, Column
class BaseObject(object):
def __init__(self, *args, **kwargs):
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import testing
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
class InheritTest(fixtures.MappedTest):
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import fixtures
-from test.lib import testing
-from test.lib.schema import Table, Column
+from sqlalchemy.testing import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing.schema import Table, Column
class PolymorphicCircularTest(fixtures.MappedTest):
"""tests basic polymorphic mapper loading/saving, minimal relationships"""
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy import exc as sa_exc
-from test.lib import Column, testing
-from test.lib.util import function_named
+from sqlalchemy.testing import Column, testing
+from sqlalchemy.testing.util import function_named
from test.orm import _fixtures
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class Person(fixtures.ComparableEntity):
pass
class_mapper
from sqlalchemy import exc as sa_exc
-from test.lib import testing
-from test.lib.testing import assert_raises, eq_
+from sqlalchemy import testing
+from sqlalchemy.testing import assert_raises, eq_
from _poly_fixtures import Company, Person, Engineer, Manager, Boss, \
Machine, Paperwork, _Polymorphic,\
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import testing
-from test.lib import fixtures
-from test.lib.schema import Table, Column
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Table, Column
class InheritTest(fixtures.MappedTest):
"""tests some various inheritance round trips involving a particular set of polymorphic inheritance relationships"""
from sqlalchemy import Integer, String, ForeignKey
from sqlalchemy.engine import default
-from test.lib import AssertsCompiledSQL, fixtures, testing
-from test.lib.schema import Table, Column
-from test.lib.testing import assert_raises, eq_
+from sqlalchemy.testing import AssertsCompiledSQL, fixtures, testing
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import assert_raises, eq_
class Company(fixtures.ComparableEntity):
pass
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import testing
+from sqlalchemy import testing
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class InheritingSelectablesTest(fixtures.MappedTest):
@classmethod
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import testing
+from sqlalchemy import testing
from test.orm import _fixtures
-from test.lib import fixtures
-from test.lib.schema import Table, Column
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Table, Column
class SingleInheritanceTest(testing.AssertsCompiledSQL, fixtures.MappedTest):
from sqlalchemy import exc as sa_exc
from sqlalchemy.engine import default
-from test.lib import AssertsCompiledSQL, fixtures, testing
-from test.lib.schema import Table, Column
-from test.lib.testing import assert_raises, eq_
+from sqlalchemy.testing import AssertsCompiledSQL, fixtures, testing
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import assert_raises, eq_
from _poly_fixtures import Company, Person, Engineer, Manager, Boss, \
Machine, Paperwork, _PolymorphicFixtureBase, _Polymorphic,\
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session
-from test.lib import fixtures
-from test.lib.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import eq_
class AssociationTest(fixtures.MappedTest):
import datetime
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, backref, create_session
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
class EagerTest(fixtures.MappedTest):
from sqlalchemy.orm.collections import collection
from sqlalchemy.orm.interfaces import AttributeExtension
from sqlalchemy import exc as sa_exc
-from test.lib import *
-from test.lib.testing import eq_, ne_, assert_raises, \
+from sqlalchemy.testing import *
+from sqlalchemy.testing import eq_, ne_, assert_raises, \
assert_raises_message
-from test.lib import fixtures
-from test.lib.util import gc_collect, all_partial_orderings
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.util import gc_collect, all_partial_orderings
from sqlalchemy.util import jython
from sqlalchemy import event
"""
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy import Integer, String, ForeignKey, Sequence, exc as sa_exc
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, relationship, create_session, \
class_mapper, backref, sessionmaker, Session
from sqlalchemy.orm import attributes, exc as orm_exc
-from test.lib import testing
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
class O2MCollectionTest(_fixtures.FixtureTest):
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy import MetaData, Integer
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, create_session
import sqlalchemy as sa
-from test.lib import testing
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
class BindTest(fixtures.MappedTest):
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy import Integer, String, ForeignKey, Sequence, \
exc as sa_exc
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session, \
sessionmaker, class_mapper, backref, Session, util as orm_util,\
configure_mappers
from sqlalchemy.orm import attributes, exc as orm_exc
-from test.lib import testing
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
class CascadeArgTest(fixtures.MappedTest):
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
import sys
from operator import and_
from sqlalchemy.orm.collections import collection
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey, text
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy import util, exc as sa_exc
from sqlalchemy.orm import create_session, mapper, relationship, \
attributes, instrumentation
-from test.lib import fixtures
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
class Canary(sa.orm.interfaces.AttributeExtension):
def __init__(self):
])
def _run_test(self, specs):
- from test.lib.util import picklers
+ from sqlalchemy.testing.util import picklers
for spec, obj, expected in specs:
coll = collections.column_mapped_collection(spec)()
eq_(
from sqlalchemy import *
from sqlalchemy import exc as sa_exc
from sqlalchemy.orm import *
-from test.lib import *
-from test.lib.testing import assert_raises_message
-from test.lib import fixtures
+from sqlalchemy.testing import *
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import fixtures
class CompileTest(fixtures.ORMTest):
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import MetaData, Integer, String, ForeignKey, func, \
util, select
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, backref, \
class_mapper, CompositeProperty, \
validates, aliased
from sqlalchemy.orm import attributes, \
composite, relationship, \
Session
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
T1/T2.
"""
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, backref, \
create_session, sessionmaker
-from test.lib.testing import eq_
-from test.lib.assertsql import RegexSQL, ExactSQL, CompiledSQL, AllOf
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing.assertsql import RegexSQL, ExactSQL, CompiledSQL, AllOf
+from sqlalchemy.testing import fixtures
class SelfReferentialTest(fixtures.MappedTest):
from test.orm import _fixtures
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy.orm import mapper, relationship, create_session
from sqlalchemy import util
from sqlalchemy.util import any
import sqlalchemy as sa
-from test.lib.testing import eq_, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises_message
class DefaultStrategyOptionsTest(_fixtures.FixtureTest):
-
import sqlalchemy as sa
from sqlalchemy import Integer, String, ForeignKey, event
-from test.lib import testing
-from test.lib.schema import Table, Column
+from sqlalchemy import testing
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session
-from test.lib import fixtures
-from test.lib.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import eq_
class TriggerDefaultsTest(fixtures.MappedTest):
be migrated directly to the wiki, docs, etc.
"""
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey, func
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, relationship, relation, create_session, sessionmaker
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class QueryAlternativesTest(fixtures.MappedTest):
from sqlalchemy import Column, Integer, func, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.util import partial
-from test.lib import fixtures
-from test.lib.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import eq_
class TestDescriptor(descriptor_props.DescriptorProperty):
def __init__(self, cls, key, descriptor=None, doc=None,
-from test.lib.testing import eq_, ne_
+from sqlalchemy.testing import eq_, ne_
import operator
from sqlalchemy.orm import dynamic_loader, backref, configure_mappers
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey, desc, select, func, exc
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session, Query, attributes, exc as orm_exc
from sqlalchemy.orm.dynamic import AppenderMixin
-from test.lib.testing import eq_, AssertsCompiledSQL, assert_raises_message, assert_raises
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, AssertsCompiledSQL, assert_raises_message, assert_raises
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
"""tests of joined-eager loaded attributes"""
-from test.lib.testing import eq_, is_, is_not_
+from sqlalchemy.testing import eq_, is_, is_not_
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy.orm import joinedload, deferred, undefer, \
joinedload_all, backref, eagerload, Session, immediateload
from sqlalchemy import Integer, String, Date, ForeignKey, and_, select, \
func
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session, \
lazyload, aliased, column_property
from sqlalchemy.sql import operators
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message
-from test.lib.assertsql import CompiledSQL
-from test.lib import fixtures
+from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
from sqlalchemy.util import OrderedDict as odict
import datetime
"""Evluating SQL expressions on ORM objects"""
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import String, Integer, select
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, create_session
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from sqlalchemy import and_, or_, not_
from sqlalchemy.orm import evaluator
-from test.lib.testing import assert_raises_message, assert_raises
+from sqlalchemy.testing import assert_raises_message, assert_raises
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, \
create_session, class_mapper, \
Mapper, column_property, \
Session, sessionmaker, attributes
from sqlalchemy.orm.instrumentation import ClassManager
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
from sqlalchemy import event
"""Attribute/instance expiration, deferral of attributes, etc."""
-from test.lib.testing import eq_, assert_raises, assert_raises_message
-from test.lib.util import gc_collect
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing.util import gc_collect
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey, exc as sa_exc
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, relationship, create_session, \
attributes, deferred, exc as orm_exc, defer, undefer,\
strategies, state, lazyload, backref, Session
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
import operator
from sqlalchemy import *
from sqlalchemy import exc as sa_exc, util
from sqlalchemy.orm import *
from sqlalchemy.orm import attributes
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
import sqlalchemy as sa
-from test.lib import testing, AssertsCompiledSQL, Column, engines
+from sqlalchemy import testing
+from sqlalchemy.testing import AssertsCompiledSQL, Column, engines
from test.orm import _fixtures
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
from sqlalchemy.orm.util import join, outerjoin, with_parent
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey, MetaData, func
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, relationship, create_session
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
"""test the current state of the hasparent() flag."""
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy import Integer, String, ForeignKey, Sequence, \
exc as sa_exc
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session, \
sessionmaker, class_mapper, backref, Session
from sqlalchemy.orm import attributes, exc as orm_exc
-from test.lib import testing
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib.util import gc_collect
+from sqlalchemy.testing.util import gc_collect
class ParentRemovalTest(fixtures.MappedTest):
"""basic tests of lazy loaded attributes"""
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy.orm import mapper, relationship, create_session, immediateload
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from test.orm import _fixtures
"""test the inspection registry system."""
-from test.lib.testing import eq_, assert_raises_message, is_
+from sqlalchemy.testing import eq_, assert_raises_message, is_
from sqlalchemy import exc, util
from sqlalchemy import inspect
from test.orm import _fixtures
from sqlalchemy.orm import class_mapper, synonym, Session, aliased
from sqlalchemy.orm.attributes import instance_state, NO_VALUE
-from test.lib import testing
+from sqlalchemy import testing
class TestORMInspection(_fixtures.FixtureTest):
@classmethod
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import sqlalchemy as sa
from sqlalchemy import MetaData, Integer, ForeignKey, util, event
from sqlalchemy.orm import mapper, relationship, create_session, \
attributes, class_mapper, clear_mappers, instrumentation, events
-from test.lib.schema import Table
-from test.lib.schema import Column
-from test.lib.testing import eq_, ne_
-from test.lib import fixtures, testing
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing import eq_, ne_
+from sqlalchemy.testing import fixtures, testing
class InitTest(fixtures.ORMTest):
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
import operator
from sqlalchemy import *
from sqlalchemy import exc as sa_exc, util
from sqlalchemy.orm import *
from sqlalchemy.orm import attributes
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
import sqlalchemy as sa
-from test.lib import testing, AssertsCompiledSQL, Column, engines
-
+from sqlalchemy import testing
+from sqlalchemy.testing import AssertsCompiledSQL, Column, engines
from test.orm import _fixtures
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
from sqlalchemy.orm.util import join, outerjoin, with_parent
"""basic tests of lazy loaded attributes"""
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import datetime
from sqlalchemy import exc as sa_exc
from sqlalchemy.orm import attributes, exc as orm_exc
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey, SmallInteger
from sqlalchemy.types import TypeDecorator
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, relationship, create_session
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
from sqlalchemy.orm import *
from sqlalchemy.ext.declarative import declarative_base
-from test.lib.testing import eq_, AssertsExecutionResults, assert_raises
-from test.lib import testing
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, AssertsExecutionResults, assert_raises
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
from sqlalchemy.orm.attributes import instance_state
from sqlalchemy.orm.exc import FlushError
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
engine = testing.db
from sqlalchemy.databases import *
from sqlalchemy.orm import mapper
from sqlalchemy.orm import Session
-from test.lib import AssertsCompiledSQL
-from test.lib.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import assert_raises_message
from test.orm import _fixtures
-from test.lib.testing import assert_raises, \
+from sqlalchemy.testing import assert_raises, \
assert_raises_message, eq_
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, relationship, create_session, \
exc as orm_exc, sessionmaker
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class M2MTest(fixtures.MappedTest):
"""General mapper operations with an emphasis on selecting/loading."""
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import MetaData, Integer, String, ForeignKey, func, util
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.engine import default
from sqlalchemy.orm import mapper, relationship, backref, \
create_session, class_mapper, configure_mappers, reconstructor, \
column_property, composite, dynamic_loader, \
comparable_property, Session
from sqlalchemy.orm.persistence import _sort_states
-from test.lib.testing import eq_, AssertsCompiledSQL, is_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, AssertsCompiledSQL, is_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib.assertsql import CompiledSQL
+from sqlalchemy.testing.assertsql import CompiledSQL
import logging
class MapperTest(_fixtures.FixtureTest, AssertsCompiledSQL):
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import sqlalchemy as sa
from sqlalchemy import Integer, PickleType, String, ForeignKey
import operator
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy.util import OrderedSet
from sqlalchemy.orm import mapper, relationship, create_session, \
PropComparator, synonym, comparable_property, sessionmaker, \
attributes, Session, backref, configure_mappers
from sqlalchemy.orm.collections import attribute_mapped_collection
from sqlalchemy.orm.interfaces import MapperOption
-from test.lib.testing import eq_, ne_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, ne_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
from sqlalchemy import event, and_, case
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
class MergeTest(_fixtures.FixtureTest):
"""Session.merge() functionality"""
"""
from __future__ import with_statement
-from test.lib.testing import eq_, ne_, \
+from sqlalchemy.testing import eq_, ne_, \
assert_raises, assert_raises_message
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey, Unicode
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session, backref, Session
from sqlalchemy.orm.session import make_transient
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
class NaturalPKTest(fixtures.MappedTest):
sess.add(u2)
sess.add(a2)
- from test.lib.assertsql import CompiledSQL
+ from sqlalchemy.testing.assertsql import CompiledSQL
# test that the primary key columns of addresses are not
# being updated as well, since this is a row switch.
contains_eager, joinedload, subqueryload, relationship,\
subqueryload_all, joinedload_all
from sqlalchemy import and_
-from test.lib import testing, fixtures
-from test.lib.testing import assert_raises, eq_
-from test.lib.schema import Column
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import assert_raises, eq_
+from sqlalchemy.testing.schema import Column
from sqlalchemy.engine import default
-from test.lib.entities import ComparableEntity
+from sqlalchemy.testing.entities import ComparableEntity
from sqlalchemy import Integer, String, ForeignKey
from .inheritance._poly_fixtures import Company, Person, Engineer, Manager, Boss, \
Machine, Paperwork, _PolymorphicFixtureBase, _Polymorphic,\
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class O2OTest(fixtures.MappedTest):
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy.util import pickle
import sqlalchemy as sa
-from test.lib import testing
-from test.lib.util import picklers
-from test.lib.testing import assert_raises_message
+from sqlalchemy import testing
+from sqlalchemy.testing.util import picklers
+from sqlalchemy.testing import assert_raises_message
from sqlalchemy import Integer, String, ForeignKey, exc, MetaData
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session, \
sessionmaker, attributes, interfaces,\
clear_mappers, exc as orm_exc,\
lazyload, aliased
from sqlalchemy.orm.collections import attribute_mapped_collection, \
column_mapped_collection
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib.pickleable import User, Address, Dingaling, Order, \
+from sqlalchemy.testing.pickleable import User, Address, Dingaling, Order, \
Child1, Child2, Parent, Screen, EmailUser
assert_raises_message(
orm_exc.UnmappedInstanceError,
- "Cannot deserialize object of type <class 'test.lib.pickleable.User'> - no mapper()",
+ "Cannot deserialize object of type <class 'sqlalchemy.testing.pickleable.User'> - no mapper()",
pickle.loads, u1_pickled)
def test_no_instrumentation(self):
-from test.lib.testing import eq_, assert_raises, assert_raises_message
import operator
from sqlalchemy import MetaData, null, exists, text, union, literal, \
literal_column, func, between, Unicode, desc, and_, bindparam, \
configure_mappers, create_session, synonym, Session, class_mapper, \
aliased, column_property, joinedload_all, joinedload, Query,\
util as orm_util
-from test.lib.assertsql import CompiledSQL
-from test.lib.testing import eq_
-from test.lib.schema import Table, Column
-
+from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.schema import Table, Column
import sqlalchemy as sa
-from test.lib import testing, AssertsCompiledSQL, engines
+from sqlalchemy import testing
+from sqlalchemy.testing.assertions import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
from test.orm import _fixtures
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures, engines
from sqlalchemy.orm.util import join, outerjoin, with_parent
-from test.lib.testing import assert_raises, assert_raises_message, eq_, \
+from sqlalchemy.testing import assert_raises, assert_raises_message, eq_, \
AssertsCompiledSQL, is_
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
from sqlalchemy.orm import relationships, foreign, remote, remote_foreign
from sqlalchemy import MetaData, Table, Column, ForeignKey, Integer, \
select, ForeignKeyConstraint, exc, func, and_
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import datetime
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import Integer, String, ForeignKey, MetaData, and_
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, relation, \
backref, create_session, configure_mappers, \
clear_mappers, sessionmaker, attributes,\
Session, composite, column_property, foreign,\
remote
from sqlalchemy.orm.interfaces import ONETOMANY, MANYTOONE, MANYTOMANY
-from test.lib.testing import eq_, startswith_, AssertsCompiledSQL, is_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, startswith_, AssertsCompiledSQL, is_
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
from sqlalchemy import exc
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy.orm import scoped_session
from sqlalchemy import Integer, String, ForeignKey
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, query
-from test.lib.testing import eq_
-from test.lib import fixtures
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
"""Generic mapping to Select statements"""
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
import sqlalchemy as sa
-from test.lib import testing
+from sqlalchemy import testing
from sqlalchemy import String, Integer, select
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, Session
-from test.lib.testing import eq_, AssertsCompiledSQL
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, AssertsCompiledSQL
+from sqlalchemy.testing import fixtures
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message, assert_warnings
-from test.lib.util import gc_collect
-from test.lib import pickleable
+from sqlalchemy.testing.util import gc_collect
+from sqlalchemy.testing import pickleable
from sqlalchemy.util import pickle
import inspect
from sqlalchemy.orm import create_session, sessionmaker, attributes, \
make_transient, Session
import sqlalchemy as sa
-from test.lib import engines, testing, config
+from sqlalchemy.testing import engines, testing, config
from sqlalchemy import Integer, String, Sequence
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, backref, joinedload, \
exc as orm_exc, object_session
from sqlalchemy.util import pypy
-from test.lib import fixtures
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
class SessionTest(_fixtures.FixtureTest):
-from test.lib.testing import eq_, is_, is_not_
-from test.lib import testing
-from test.lib.schema import Table, Column
+from sqlalchemy.testing import eq_, is_, is_not_
+from sqlalchemy import testing
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy import Integer, String, ForeignKey, bindparam, inspect
from sqlalchemy.orm import backref, subqueryload, subqueryload_all, \
mapper, relationship, clear_mappers, create_session, lazyload, \
aliased, joinedload, deferred, undefer, eagerload_all,\
Session
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message
-from test.lib.assertsql import CompiledSQL
-from test.lib import fixtures
+from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
import sqlalchemy as sa
-from test.lib.testing import eq_, assert_raises, assert_raises_message
-from test.lib import testing
-from test.lib.schema import Table, Column
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy import testing
+from sqlalchemy.testing.schema import Table, Column
from test.orm import _fixtures
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
from sqlalchemy import Integer, String, ForeignKey, func
from sqlalchemy.orm import mapper, relationship, backref, \
create_session, unitofwork, attributes,\
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message, assert_warnings
from sqlalchemy import *
from sqlalchemy.orm import attributes
from sqlalchemy import exc as sa_exc, event
from sqlalchemy.orm import exc as orm_exc
from sqlalchemy.orm import *
-from test.lib.util import gc_collect
-from test.lib import testing
-from test.lib import fixtures
-from test.lib import engines
+from sqlalchemy.testing.util import gc_collect
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import engines
from test.orm._fixtures import FixtureTest
# coding: utf-8
"""Tests unitofwork operations."""
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
import datetime
import operator
from sqlalchemy.orm import mapper as orm_mapper
import sqlalchemy as sa
from sqlalchemy import Integer, String, ForeignKey, literal_column, event
-from test.lib import engines, testing, pickleable
-from test.lib.schema import Table
-from test.lib.schema import Column
+from sqlalchemy.testing import engines, testing, pickleable
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.schema import Column
from sqlalchemy.orm import mapper, relationship, create_session, \
column_property, attributes, Session, reconstructor, object_session,\
exc as orm_exc
-from test.lib.testing import eq_, ne_
-from test.lib.util import gc_collect
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, ne_
+from sqlalchemy.testing.util import gc_collect
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib import fixtures
-from test.lib.assertsql import AllOf, CompiledSQL
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.assertsql import AllOf, CompiledSQL
import gc
class UnitOfWorkTest(object):
-from test.lib.testing import eq_, assert_raises, assert_raises_message
-from test.lib import testing, engines
-from test.lib.schema import Table, Column
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
+from sqlalchemy.testing.schema import Table, Column
from test.orm import _fixtures
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
from sqlalchemy import Integer, String, ForeignKey, func
from sqlalchemy.orm import mapper, relationship, backref, \
create_session, unitofwork, attributes,\
Session, class_mapper, sync, exc as orm_exc
-from test.lib.assertsql import AllOf, CompiledSQL
+from sqlalchemy.testing.assertsql import AllOf, CompiledSQL
class AssertsUOW(object):
def _get_test_uow(self, session):
-from test.lib.testing import eq_, assert_raises, assert_raises_message
-from test.lib import fixtures, testing
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import fixtures, testing
from sqlalchemy import Integer, String, ForeignKey, or_, and_, exc, select, func
from sqlalchemy.orm import mapper, relationship, backref, Session, joinedload
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy.orm import interfaces, util
from sqlalchemy import Column
from sqlalchemy import Integer
from sqlalchemy import Table
from sqlalchemy.orm import aliased
from sqlalchemy.orm import mapper, create_session
-from test.lib import testing
-from test.lib import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
class AliasedClassTest(fixtures.TestBase):
import datetime
import sqlalchemy as sa
-from test.lib import engines, testing
+from sqlalchemy.testing import engines, testing
from sqlalchemy import Integer, String, Date, ForeignKey, literal_column, \
orm, exc, select, TypeDecorator
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, Session, \
create_session, column_property, sessionmaker,\
exc as orm_exc
-from test.lib.testing import eq_, ne_, assert_raises, assert_raises_message
-from test.lib import fixtures
+from sqlalchemy.testing import eq_, ne_, assert_raises, assert_raises_message
+from sqlalchemy.testing import fixtures
from test.orm import _fixtures
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
_uuids = [
import sys, time
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import profiling
+from sqlalchemy.testing import profiling
db = create_engine('sqlite://')
metadata = MetaData(db)
from sqlalchemy import Column, ForeignKey
from sqlalchemy import Integer, String
from sqlalchemy.orm import mapper
-from test.lib import profiling
+from sqlalchemy.testing import profiling
class Object(object):
pass
import time, resource
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib.util import gc_collect
-from test.lib import profiling
+from sqlalchemy.testing.util import gc_collect
+from sqlalchemy.testing import profiling
db = create_engine('sqlite://')
metadata = MetaData(db)
import time, resource
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import *
-from test.lib.util import gc_collect
+from sqlalchemy.testing import *
+from sqlalchemy.testing.util import gc_collect
NUM = 100
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib import *
-from test.lib.profiling import profiled
+from sqlalchemy.testing import *
+from sqlalchemy.testing.profiling import profiled
class Item(object):
def __repr__(self):
from sqlalchemy import *
from sqlalchemy.orm import *
-from test.lib.compat import gc_collect
-from test.lib import AssertsExecutionResults, profiling, testing
+from sqlalchemy.testing.compat import gc_collect
+from sqlalchemy.testing import AssertsExecutionResults, profiling, testing
from test.orm import _fixtures
# in this test we are specifically looking for time spent in the attributes.InstanceState.__cleanup() method.
"""
-from .exclusions import \
+from sqlalchemy import util
+import sys
+from sqlalchemy.testing.suite.requirements import SuiteRequirements
+from sqlalchemy.testing.exclusions import \
skip, \
skip_if,\
only_if,\
def exclude(db, op, spec, description=None):
return SpecPredicate(db, op, spec, description=description)
-from sqlalchemy import util
-from ..bootstrap import config
-import sys
crashes = skip
return fn
return decorate
-class Requirements(object):
- def __init__(self, db, config):
- self.db = db
- self.config = config
-
-
-class DefaultRequirements(Requirements):
+class DefaultRequirements(SuiteRequirements):
@property
def deferrable_or_no_constraints(self):
"""Target database must support derferable constraints."""
"""
return _chain_decorators_on(
- skip_if(lambda: config.options.low_connections)
+ skip_if(lambda: self.config.options.low_connections)
)
@property
-from test.lib.testing import assert_raises, assert_raises_message, eq_
+from sqlalchemy.testing import assert_raises, assert_raises_message, eq_
import sys
from sqlalchemy import *
-from test.lib import *
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL
+from sqlalchemy import testing
from sqlalchemy import util, exc
from sqlalchemy.sql import table, column
"""
-from test.lib.testing import eq_, is_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, is_, assert_raises, assert_raises_message
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL
import datetime, re, operator, decimal
from sqlalchemy import *
from sqlalchemy import exc, sql, util, types, schema
from sqlalchemy.sql.expression import ClauseList, _literal_as_text, HasPrefixes
from sqlalchemy.engine import default
from sqlalchemy.databases import *
-from test.lib import *
from sqlalchemy.ext.compiler import compiles
table1 = table('mytable',
-from test.lib.testing import assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy import *
from sqlalchemy import exc, schema
-from test.lib import *
-from test.lib import config, engines
+from sqlalchemy.testing import fixtures, AssertsExecutionResults, AssertsCompiledSQL
+from sqlalchemy import testing
+from sqlalchemy.testing import config, engines
from sqlalchemy.engine import ddl
-from test.lib.testing import eq_
-from test.lib.assertsql import AllOf, RegexSQL, ExactSQL, CompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing.assertsql import AllOf, RegexSQL, ExactSQL, CompiledSQL
from sqlalchemy.dialects.postgresql import base as postgresql
class ConstraintTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiledSQL):
-from test.lib import fixtures
-from test.lib.testing import AssertsCompiledSQL, assert_raises_message
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import AssertsCompiledSQL, assert_raises_message
from sqlalchemy.sql import table, column, select, func, literal
from sqlalchemy.dialects import mssql
from sqlalchemy.engine import default
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
import datetime
from sqlalchemy.schema import CreateSequence, DropSequence
from sqlalchemy.sql import select, text, literal_column
import sqlalchemy as sa
-from test.lib import testing, engines
+from sqlalchemy import testing
+from sqlalchemy.testing import engines
from sqlalchemy import MetaData, Integer, String, ForeignKey, Boolean, exc,\
Sequence, func, literal, Unicode
from sqlalchemy.types import TypeDecorator, TypeEngine
-from test.lib.schema import Table, Column
-from test.lib.testing import eq_
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import eq_
from sqlalchemy.dialects import sqlite
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
class DefaultTest(fixtures.TestBase):
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
import datetime
from sqlalchemy import *
from sqlalchemy.sql import table, column
from sqlalchemy import sql, util
from sqlalchemy.sql.compiler import BIND_TEMPLATES
-from test.lib.engines import all_dialects
+from sqlalchemy.testing.engines import all_dialects
from sqlalchemy import types as sqltypes
from sqlalchemy.sql import functions
from sqlalchemy.sql.functions import GenericFunction
from sqlalchemy.util.compat import decimal
-from test.lib import testing, fixtures, AssertsCompiledSQL, engines
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL, engines
from sqlalchemy.dialects import sqlite, postgresql, mysql, oracle
from sqlalchemy import *
from sqlalchemy.sql import table, column, ClauseElement, operators
from sqlalchemy.sql.expression import _clone, _from_objects
-from test.lib import *
-from sqlalchemy.sql.visitors import *
+from sqlalchemy.testing import fixtures, AssertsExecutionResults, \
+ AssertsCompiledSQL
+from sqlalchemy import testing
+from sqlalchemy.sql.visitors import ClauseVisitor, CloningVisitor, \
+ cloned_traverse, ReplacingCloningVisitor
from sqlalchemy import util, exc
from sqlalchemy.sql import util as sql_util
-from test.lib.testing import eq_, ne_, assert_raises
+from sqlalchemy.testing import eq_, ne_, assert_raises
class TraversalTest(fixtures.TestBase, AssertsExecutionResults):
"""test ClauseVisitor's traversal, particularly its
from sqlalchemy import inspect
from sqlalchemy import Table, Column, Integer, MetaData
-from test.lib import fixtures
-from test.lib.testing import is_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
class TestCoreInspection(fixtures.TestBase):
-from test.lib.testing import assert_raises, assert_raises_message, eq_
-from test.lib.engines import testing_engine
-from test.lib import fixtures, AssertsCompiledSQL, testing
+from sqlalchemy.testing import assert_raises, assert_raises_message, eq_
+from sqlalchemy.testing.engines import testing_engine
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL
+from sqlalchemy import testing
from sqlalchemy import *
from sqlalchemy import exc as exceptions
from sqlalchemy.engine import default
from sqlalchemy.sql import table, column
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
IDENT_LENGTH = 29
-from test.lib.testing import assert_raises
-from test.lib.testing import assert_raises_message
-from test.lib.testing import emits_warning
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import emits_warning
import pickle
from sqlalchemy import Integer, String, UniqueConstraint, \
CheckConstraint, ForeignKey, MetaData, Sequence, \
ForeignKeyConstraint, ColumnDefault, Index, event,\
events, Unicode
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy import schema, exc
import sqlalchemy as tsa
-from test.lib import fixtures
-from test.lib import testing
-from test.lib.testing import ComparesTables, AssertsCompiledSQL
-from test.lib.testing import eq_, is_
+from sqlalchemy.testing import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import ComparesTables, AssertsCompiledSQL
+from sqlalchemy.testing import eq_, is_
class MetaDataTest(fixtures.TestBase, ComparesTables):
def test_metadata_connect(self):
-from test.lib import fixtures, testing
-from test.lib.testing import assert_raises_message
+from sqlalchemy.testing import fixtures
+from sqlalchemy import testing
+from sqlalchemy.testing import assert_raises_message
from sqlalchemy.sql import column, desc, asc, literal, collate
from sqlalchemy.sql.expression import BinaryExpression, \
ClauseList, Grouping, \
-from test.lib.testing import eq_, assert_raises_message, assert_raises, is_
+from sqlalchemy.testing import eq_, assert_raises_message, assert_raises, is_
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures, engines
+from sqlalchemy import util
import datetime
from sqlalchemy import *
-from sqlalchemy import exc, sql, util
+from sqlalchemy import exc, sql
from sqlalchemy.engine import default, result as _result
-from test.lib import *
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
class QueryTest(fixtures.TestBase):
from sqlalchemy import *
from sqlalchemy import sql, schema
from sqlalchemy.sql import compiler
-from test.lib import *
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL
+from sqlalchemy import testing
class QuoteTest(fixtures.TestBase, AssertsCompiledSQL):
__dialect__ = 'default'
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
from sqlalchemy import *
-from test.lib import *
-from test.lib.schema import Table, Column
+from sqlalchemy import testing
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.types import TypeDecorator
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures, AssertsExecutionResults, engines
class ReturningTest(fixtures.TestBase, AssertsExecutionResults):
__requires__ = 'returning',
from sqlalchemy import *
-from test.lib import *
+from sqlalchemy.testing import fixtures, AssertsExecutionResults
+from sqlalchemy import testing
class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults):
"""Test various algorithmic properties of selectables."""
-from test.lib.testing import eq_, assert_raises, \
+from sqlalchemy.testing import eq_, assert_raises, \
assert_raises_message, is_
from sqlalchemy import *
-from test.lib import *
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL, \
+ AssertsExecutionResults
+from sqlalchemy import testing
from sqlalchemy.sql import util as sql_util, visitors
from sqlalchemy import exc
from sqlalchemy.sql import table, column, null
from sqlalchemy import util
-from test.lib import fixtures
+from sqlalchemy.testing import fixtures
metadata = MetaData()
table1 = Table('table1', metadata,
from sqlalchemy import Table, Column, String, func, MetaData, select, TypeDecorator, cast
-from test.lib import fixtures, AssertsCompiledSQL, testing
-from test.lib.testing import eq_
+from sqlalchemy.testing import fixtures, AssertsCompiledSQL
+from sqlalchemy import testing
+from sqlalchemy.testing import eq_
+
class _ExprFixture(object):
def _fixture(self):
# coding: utf-8
-from test.lib.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
import decimal
import datetime, os, re
from sqlalchemy import *
for name in dialects.__all__:
__import__("sqlalchemy.dialects.%s" % name)
from sqlalchemy.sql import operators, column, table
-from test.lib.testing import eq_
+from sqlalchemy.testing import eq_
import sqlalchemy.engine.url as url
from sqlalchemy.engine import default
-from test.lib.schema import Table, Column
-from test.lib import *
-from test.lib.util import picklers
+from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy import testing
+from sqlalchemy.testing import AssertsCompiledSQL, AssertsExecutionResults, \
+ engines, pickleable
+from sqlalchemy.testing.util import picklers
from sqlalchemy.util.compat import decimal
-from test.lib.util import round_decimal
-from test.lib import fixtures
+from sqlalchemy.testing.util import round_decimal
+from sqlalchemy.testing import fixtures
class AdaptTest(fixtures.TestBase):
def _all_dialect_modules(self):
"""verrrrry basic unicode column name testing"""
from sqlalchemy import *
-from test.lib import fixtures, engines, testing
-from test.lib.engines import utf8_engine
+from sqlalchemy.testing import fixtures, engines
+from sqlalchemy import testing
+from sqlalchemy.testing.engines import utf8_engine
from sqlalchemy.sql import column
-from test.lib.schema import Table, Column
+from sqlalchemy.testing.schema import Table, Column
class UnicodeSchemaTest(fixtures.TestBase):
__requires__ = ('unicode_ddl',)
-from test.lib.testing import eq_, assert_raises_message, assert_raises, AssertsCompiledSQL
+from sqlalchemy.testing import eq_, assert_raises_message, assert_raises, AssertsCompiledSQL
import datetime
from sqlalchemy import *
from sqlalchemy import exc, sql, util
from sqlalchemy.engine import default, base
-from test.lib import *
-from test.lib.schema import Table, Column
+from sqlalchemy import testing
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.dialects import mysql
class _UpdateFromTestBase(object):
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
