def test_declarative_base_metadata_precedence():
"""Test that delcarative_base() applies precedence to metadata option."""
metadata1 = MetaData()
metadata2 = MetaData()
class Base(object):
metadata = metadata1
Model1 = declarative_base(Base)
assert Model1.metadata is metadata1
Model2 = declarative_base(Base, metadata=metadata2)
assert Model2.metadata is metadata2
def test_declarative_base_metaclass_as_arg():
"""Test that declarative_base() accepts a metaclass argument."""
class MetaClass(DeclarativeMeta):
pass
Model = declarative_base(metaclass=MetaClass)
assert Model.metaclass is MetaClass
def test_declarative_base_metaclass_precedence():
"""Test that delcarative_base() applies precedence to metaclass option."""
class MetaClass1(DeclarativeMeta):
pass
class MetaClass2(DeclarativeMeta):
pass
class Base(object):
metaclass = MetaClass1
Model1 = declarative_base(Base)
assert Model1.metaclass is MetaClass1
Model2 = declarative_base(Base, metaclass=MetaClass2)
assert Model2.metaclass is MetaClass2
def test_declarative_base_metadata_on_class():
"""Test that delcarative_base() accepts metadata defined on class."""
_metadata = MetaData()
class Base(object):
metadata = _metadata
Model = declarative_base(Base)
assert Model.metadata is _metadata
def test_declarative_base_metaclass_on_class():
"""Test that delcarative_base() accepts metaclass defined on class."""
class MetaClass(DeclarativeMeta):
pass
class Base(object):
metaclass = MetaClass
Model = declarative_base(Base)
assert Model.metaclass is MetaClass
def test_declarative_base():
"""Test declarative_base()."""
class MetaClass(DeclarativeMeta):
pass
metadata = MetaData()
Model = declarative_base(metadata=metadata, metaclass=MetaClass)
assert Model.__bases__[0] is ModelBase
assert Model.metadata is metadata
assert Model.metaclass is MetaClass
def test_declarative_base():
"""Test declarative_base()."""
class MetaClass(DeclarativeMeta):
pass
metadata = MetaData()
Model = declarative_base(metadata=metadata, metaclass=MetaClass)
assert Model.__bases__[0] is ModelBase
assert Model.metadata is metadata
assert Model.metaclass is MetaClass
def test_declarative_base__can_override_defaults():
class MetaClass(ModelMeta):
pass
metadata = MetaData()
Base = declarative_base(metadata=metadata,
metaclass=MetaClass,
name="Base")
assert_declarative_base(Base, name="Base")
assert Base.metadata is metadata
assert isinstance(Base, MetaClass)
def test_declarative_base_metadata_as_arg():
"""Test that declarative_base() accepts a metadata argument."""
_metadata = MetaData()
Model = declarative_base(metadata=_metadata)
assert Model.metadata is _metadata
import re
from sqlalchemy import Column, ForeignKey, orm, types
from sqlservice import declarative_base, event
from sqlservice import SQLClient
import sqlalchemy.dialects.mysql.pymysql
Model = declarative_base()
class User(Model):
__tablename__ = 'user'
id = Column(types.Integer(), primary_key=True)
name = Column(types.String(100))
email = Column(types.String(100))
phone = Column(types.String(10))
roles = orm.relation('UserRole')
@event.on_set('phone', retval=True)
def on_set_phone(self, value, oldvalue, initator):
# Strip non-numeric characters from phone number.
return re.sub('[^0-9]', '', value)
class UserRole(Model):
__tablename__ = 'user_role'
id = Column(types.Integer(), primary_key=True)
user_id = Column(types.Integer(), ForeignKey('user.id'), nullable=False)
role = Column(types.String(25), nullable=False)
# database models for datadrop
import datetime
import pytimeparse
from sqlalchemy import Column, ForeignKey, MetaData, types
from sqlalchemy.orm import relationship
from sqlservice import ModelBase, declarative_base
from app import app
import utils
meta = MetaData()
Model = declarative_base(ModelBase, metadata=meta)
class Drop(Model):
"""Represents a single "drop" of data, as well as any drop keys it's associated with it."""
__tablename__ = 'drops'
id = Column(types.Integer, primary_key=True)
urlstring = Column(types.String(256),
default=utils.random_string(
app.config['DATADROP_URLSTRING_LENGTH']),
unique=True,
nullable=False)
title = Column(types.String(256))
# In the future, I might want to split the actual "data" up from the "drops" table, so as to more efficiently store repeated pieces of data
# but for now:
data = Column(types.Text(268435456), nullable=False) # Limited to 256 mb
created_at = Column(types.DateTime,
default=datetime.datetime.utcnow(),
nullable=False)
import sys
from unittest import mock
import pytest
import sqlalchemy as sa
from sqlalchemy.orm.collections import attribute_mapped_collection
from sqlservice import SQLClient, declarative_base
# Alias long method name.
parametrize = pytest.mark.parametrize
Model = declarative_base()
DupModel = declarative_base()
def unique_id():
if not hasattr(unique_id, '_id'):
unique_id._id = 0
unique_id._id += 1
return unique_id._id
class AModel(Model):
__tablename__ = 'test_a'
id = sa.Column(sa.types.Integer(),
primary_key=True,
app.config.from_object("config")
def as_dict(self, *exclude):
if not exclude:
exclude = []
exclude = [".".join([self.__tablename__, c]) for c in exclude]
return {
c.name: getattr(self, c.name)
for c in self.__table__.columns if str(c) not in exclude
}
BaseModel = sqlservice.declarative_base()
BaseModel.as_dict = as_dict
class Advisor(BaseModel):
__tablename__ = "Advisor"
id = Column(INTEGER, primary_key=True)
name = Column(VARCHAR(255), nullable=False)
email = Column(VARCHAR(255), nullable=False)
is_undergraduate = Column(BOOLEAN, nullable=False)
db = sqlservice.SQLClient(
{"SQL_DATABASE_URI": app.config["SQLALCHEMY_DATABASE_URI"]},
model_class=BaseModel)
def test_declarative_base__returns_new_base_class():
Base1 = declarative_base()
Base2 = declarative_base()
assert Base1 is not Base2
def test_declarative_base():
Base = declarative_base()
assert_declarative_base(Base, name="ModelBase")
