def setUp(self):
self.engine = create_engine('sqlite:///:memory:', echo=True)
self.Base = declarative_base(self.engine)
self.session_handler = ScopedSessionHandler(self.engine)
class MyModel(self.Base):
__tablename__ = 'my_model'
id = Column(Integer, primary_key=True)
value = Column(String(length=63))
self.model = MyModel
self.Base.metadata.create_all()
class MyManager(AlchemyManager):
model = self.model
fields = (
'id',
'value',
)
paginate_by = 10
self.manager = MyManager(self.session_handler)
class MyResource(restmixins.RetrieveList):
manager = self.manager
pks = ('id', )
resource_name = 'my_resource'
self.resource = MyResource
def setUp(self):
self.engine = create_engine('sqlite:///:memory:', echo=True)
self.Base = declarative_base(self.engine)
self.session_handler = ScopedSessionHandler(self.engine)
self.session = Session(self.engine)
class One(self.Base):
__tablename__ = 'one'
id = Column(Integer, primary_key=True)
value = Column(String(length=50))
manies = relationship("Many", backref='one')
class Many(self.Base):
__tablename__ = 'many'
id = Column(Integer, primary_key=True)
many_value = Column(String(length=50))
one_id = Column(Integer, ForeignKey('one.id'))
class DefaultManager(AlchemyManager):
session = self.session
model = One
fields = ['id', 'value', 'manies.id']
self.model = One
self._manager = DefaultManager
self.One = One
self.Many = Many
self.Base.metadata.create_all()
def setUp(self):
self.engine = create_engine('sqlite:///:memory:', echo=True)
self.Base = declarative_base(self.engine)
self.session_handler = ScopedSessionHandler(self.engine)
class MyModel(self.Base):
__tablename__ = 'my_model'
id = Column(Integer, primary_key=True)
value = Column(String(length=63))
self.model = MyModel
self.Base.metadata.create_all()
class MyManager(AlchemyManager):
model = self.model
fields = ('id', 'value',)
paginate_by = 10
self.manager = MyManager(self.session_handler)
class MyResource(restmixins.RetrieveList):
manager = self.manager
pks = ('id',)
resource_name = 'my_resource'
self.resource = MyResource
class TestEasyResource(unittest2.TestCase):
def setUp(self):
self.engine = create_engine('sqlite:///:memory:')
self.session_handler = ScopedSessionHandler(self.engine)
Base.metadata.create_all(self.engine)
def tearDown(self):
if self.engine:
self.engine.dispose()
self.engine = None
def test_create_resource(self):
resource = create_resource(MyModel, self.session_handler)
req = RequestContainer(body_args=dict(value='blah'))
resp = resource.create(req)
self.assertEqual(resp.properties['value'], 'blah')
id_ = resp.properties['id']
session = self.session_handler.get_session()
resp = session.query(MyModel).get(id_)
self.assertIsNotNone(resp)
self.assertEqual(resp.value, 'blah')
retrieved = resource.retrieve(
RequestContainer(url_params=dict(id=id_)))
self.assertEqual(retrieved.properties['value'], 'blah')
retrieved_list = resource.retrieve_list(RequestContainer())
self.assertEqual(len(retrieved_list.related_resources), 1)
relatec = retrieved_list.related_resources[0].resource
self.assertEqual(len(relatec), 1)
updated = resource.update(
RequestContainer(url_params=dict(id=id_),
body_args=dict(value='new')))
self.assertEqual(updated.properties['value'], 'new')
session = self.session_handler.get_session()
model = session.query(MyModel).get(id_)
self.assertEqual(model.value, 'new')
deleted = resource.delete(RequestContainer(url_params=dict(id=id_)))
session = self.session_handler.get_session()
model = session.query(MyModel).get(id_)
self.assertIsNone(model)
class TestEasyResource(unittest2.TestCase):
def setUp(self):
self.engine = create_engine('sqlite:///:memory:')
self.session_handler = ScopedSessionHandler(self.engine)
Base.metadata.create_all(self.engine)
def tearDown(self):
if self.engine:
self.engine.dispose()
self.engine = None
def test_create_resource(self):
resource = create_resource(MyModel, self.session_handler)
req = RequestContainer(body_args=dict(value='blah'))
resp = resource.create(req)
self.assertEqual(resp.properties['value'], 'blah')
id_ = resp.properties['id']
session = self.session_handler.get_session()
resp = session.query(MyModel).get(id_)
self.assertIsNotNone(resp)
self.assertEqual(resp.value, 'blah')
retrieved = resource.retrieve(RequestContainer(url_params=dict(id=id_)))
self.assertEqual(retrieved.properties['value'], 'blah')
retrieved_list = resource.retrieve_list(RequestContainer())
self.assertEqual(len(retrieved_list.related_resources), 1)
relatec = retrieved_list.related_resources[0].resource
self.assertEqual(len(relatec), 1)
updated = resource.update(RequestContainer(url_params=dict(id=id_),
body_args=dict(value='new')))
self.assertEqual(updated.properties['value'], 'new')
session = self.session_handler.get_session()
model = session.query(MyModel).get(id_)
self.assertEqual(model.value, 'new')
deleted = resource.delete(RequestContainer(url_params=dict(id=id_)))
session = self.session_handler.get_session()
model = session.query(MyModel).get(id_)
self.assertIsNone(model)
def test_resource_construction(self):
"""Simple Resource construction"""
with self.app.app_context():
user = self.db.session.query(User).filter_by(username='******').first()
man_model = ManagerModel(model_name='blah', owner=user, fields=('id',))
self.db.session.add(man_model)
self.db.session.commit()
res = ResourceModel(restmixin='CRUDL', manager=man_model, owner=user)
res.pks = ['id']
resource_class = res.resource
self.assertEqual(restmixins.CRUDL, res.restmixin_class)
self.assertIsInstance(resource_class, ResourceMetaClass)
req = RequestContainer()
resource_instance = resource_class.create(req)
self.assertIsInstance(resource_instance, resource_class)
id_ = resource_instance.properties['id']
engine = get_database_engine(user)
session = ScopedSessionHandler(engine).get_session()
model = session.query(self.model).get(id_)
self.assertIsNotNone(model)
self.assertListEqual(res.pks, ['id'])
self.assertEqual(res._pks, '["id"]')
def setUp(self):
self.engine = create_engine('sqlite:///:memory:', echo=True)
self.Base = declarative_base(self.engine)
self.session_handler = ScopedSessionHandler(self.engine)
self.session = Session(self.engine)
class MyModel(self.Base):
__tablename__ = 'my_model'
id = Column(Integer, primary_key=True)
big_integer = Column(BigInteger)
boolean = Column(Boolean)
date = Column(Date)
date_time = Column(DateTime)
enum = Column(Enum('one', 'two' 'three'))
float = Column(Float)
integer = Column(Integer)
interval = Column(Interval)
large_binary = Column(LargeBinary)
numeric = Column(Numeric)
pickle_type = Column(PickleType)
small_integer = Column(SmallInteger)
string = Column(String)
text = Column(Text)
time = Column(Time)
unicode = Column(Unicode)
unicode_text = Column(UnicodeText)
self.model = MyModel
self.Base.metadata.create_all()
class ModelManager(AlchemyManager):
model = self.model
fields = [
'id', 'big_integer', 'boolean', 'date', 'date_time', 'enum',
'float', 'integer', 'interval', 'large_binary', 'numeric',
'pickle_type', 'small_integer', 'string', 'text', 'time',
'unicode', 'unicode_text'
]
self._manager = ModelManager
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import re
from ripozo.resources.fields.common import StringField
from ripozo_sqlalchemy import AlchemyManager, ScopedSessionHandler
from common.models import engine, Post, Comment
session_handler = ScopedSessionHandler(engine)
class PostManager(AlchemyManager):
model = Post
fields = (
'id',
'username',
'post_text',
'comments.id',
)
create_fields = (
'username',
'post_text',
)
_field_validators = {
'username':
StringField('username', minimum=3, regex=re.compile(r'^[a-zA-Z0-9]+$'))
}
class TestPagination(unittest2.TestCase):
def setUp(self):
self.engine = create_engine('sqlite:///:memory:', echo=True)
self.Base = declarative_base(self.engine)
self.session_handler = ScopedSessionHandler(self.engine)
class MyModel(self.Base):
__tablename__ = 'my_model'
id = Column(Integer, primary_key=True)
value = Column(String(length=63))
self.model = MyModel
self.Base.metadata.create_all()
class MyManager(AlchemyManager):
model = self.model
fields = ('id', 'value',)
paginate_by = 10
self.manager = MyManager(self.session_handler)
class MyResource(restmixins.RetrieveList):
manager = self.manager
pks = ('id',)
resource_name = 'my_resource'
self.resource = MyResource
def tearDown(self):
self.engine.dispose()
def create_models(self, count=5):
session = self.session_handler.get_session()
for i in range(count):
m = self.model(value=''.join(random.choice(string.ascii_letters) for _ in range(63)))
session.add(m)
session.commit()
session.close()
def get_linked_resource(self, resource, name):
for linked in resource.linked_resources:
if linked.name == name:
return linked.resource
return None
def test_empty(self):
"""
Tests for when no models have been created
"""
req = RequestContainer()
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.linked_resources), 0)
self.assertEqual(len(resource.properties['my_resource']), 0)
def test_not_enough_for_pagination(self):
"""
Tests that no pagination links are available when
there are less than or equal the paginate_by count
of records.
"""
self.create_models(count=10)
req = RequestContainer()
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.linked_resources), 0)
self.assertEqual(len(resource.properties['my_resource']), 10)
def test_next_pagination(self):
"""
Tests basic forward pagination end on
a multiple of the paginate_by
"""
self.create_models(count=100)
req = RequestContainer()
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count = 1
while self.get_linked_resource(resource, 'next'):
next_link = self.get_linked_resource(resource, 'next')
req = RequestContainer(query_args=next_link.get_query_arg_dict())
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count += 1
self.assertEqual(10, count)
def test_next_pagination_partial_end(self):
"""
Tests forward pagination that ends with a
partial page (i.e. less than the paginate_by)
"""
self.create_models(count=101)
req = RequestContainer()
resource = self.resource.retrieve_list(req)
count = 1
while self.get_linked_resource(resource, 'next'):
self.assertEqual(len(resource.properties['my_resource']), 10)
next_link = self.get_linked_resource(resource, 'next')
req = RequestContainer(query_args=next_link.get_query_arg_dict())
resource = self.resource.retrieve_list(req)
count += 1
self.assertEqual(len(resource.properties['my_resource']), 1)
self.assertEqual(11, count)
def test_prev_pagintation(self):
"""
Tests prev pagination with the total count
of models as a multiple of the paginate_by
"""
self.create_models(count=100)
req = RequestContainer(query_args=dict(page=10))
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count = 1
while self.get_linked_resource(resource, 'previous'):
previous = self.get_linked_resource(resource, 'previous')
req = RequestContainer(query_args=previous.get_query_arg_dict())
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count += 1
self.assertEqual(10, count)
def test_prev_pagination_uneven_total(self):
"""
Tests previous pagination with the total count
of models not as a multiple of the paginate_by.
"""
self.create_models(count=101)
req = RequestContainer(query_args=dict(page=11))
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 1)
count = 1
while self.get_linked_resource(resource, 'previous'):
previous = self.get_linked_resource(resource, 'previous')
req = RequestContainer(query_args=previous.get_query_arg_dict())
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count += 1
self.assertEqual(11, count)
def manager(self):
session_handler = ScopedSessionHandler(self.engine)
return PersonManager(session_handler)
def setUp(self):
self.engine = create_engine('sqlite:///:memory:')
self.session_handler = ScopedSessionHandler(self.engine)
Base.metadata.create_all(self.engine)
class TestPagination(unittest2.TestCase):
def setUp(self):
self.engine = create_engine('sqlite:///:memory:', echo=True)
self.Base = declarative_base(self.engine)
self.session_handler = ScopedSessionHandler(self.engine)
class MyModel(self.Base):
__tablename__ = 'my_model'
id = Column(Integer, primary_key=True)
value = Column(String(length=63))
self.model = MyModel
self.Base.metadata.create_all()
class MyManager(AlchemyManager):
model = self.model
fields = (
'id',
'value',
)
paginate_by = 10
self.manager = MyManager(self.session_handler)
class MyResource(restmixins.RetrieveList):
manager = self.manager
pks = ('id', )
resource_name = 'my_resource'
self.resource = MyResource
def tearDown(self):
self.engine.dispose()
def create_models(self, count=5):
session = self.session_handler.get_session()
for i in range(count):
m = self.model(value=''.join(
random.choice(string.ascii_letters) for _ in range(63)))
session.add(m)
session.commit()
session.close()
def get_linked_resource(self, resource, name):
for linked in resource.linked_resources:
if linked.name == name:
return linked.resource
return None
def test_empty(self):
"""
Tests for when no models have been created
"""
req = RequestContainer()
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.linked_resources), 0)
self.assertEqual(len(resource.properties['my_resource']), 0)
def test_not_enough_for_pagination(self):
"""
Tests that no pagination links are available when
there are less than or equal the paginate_by count
of records.
"""
self.create_models(count=10)
req = RequestContainer()
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.linked_resources), 0)
self.assertEqual(len(resource.properties['my_resource']), 10)
def test_next_pagination(self):
"""
Tests basic forward pagination end on
a multiple of the paginate_by
"""
self.create_models(count=100)
req = RequestContainer()
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count = 1
while self.get_linked_resource(resource, 'next'):
next_link = self.get_linked_resource(resource, 'next')
req = RequestContainer(query_args=next_link.get_query_arg_dict())
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count += 1
self.assertEqual(10, count)
def test_next_pagination_partial_end(self):
"""
Tests forward pagination that ends with a
partial page (i.e. less than the paginate_by)
"""
self.create_models(count=101)
req = RequestContainer()
resource = self.resource.retrieve_list(req)
count = 1
while self.get_linked_resource(resource, 'next'):
self.assertEqual(len(resource.properties['my_resource']), 10)
next_link = self.get_linked_resource(resource, 'next')
req = RequestContainer(query_args=next_link.get_query_arg_dict())
resource = self.resource.retrieve_list(req)
count += 1
self.assertEqual(len(resource.properties['my_resource']), 1)
self.assertEqual(11, count)
def test_prev_pagintation(self):
"""
Tests prev pagination with the total count
of models as a multiple of the paginate_by
"""
self.create_models(count=100)
req = RequestContainer(query_args=dict(page=10))
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count = 1
while self.get_linked_resource(resource, 'previous'):
previous = self.get_linked_resource(resource, 'previous')
req = RequestContainer(query_args=previous.get_query_arg_dict())
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count += 1
self.assertEqual(10, count)
def test_prev_pagination_uneven_total(self):
"""
Tests previous pagination with the total count
of models not as a multiple of the paginate_by.
"""
self.create_models(count=101)
req = RequestContainer(query_args=dict(page=11))
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 1)
count = 1
while self.get_linked_resource(resource, 'previous'):
previous = self.get_linked_resource(resource, 'previous')
req = RequestContainer(query_args=previous.get_query_arg_dict())
resource = self.resource.retrieve_list(req)
self.assertEqual(len(resource.properties['my_resource']), 10)
count += 1
self.assertEqual(11, count)
def manager(self):
session_handler = ScopedSessionHandler(self.engine)
self.session_handler = session_handler
self.session = self.session_handler.get_session()
return self._manager(self.session_handler)
def setUp(self):
self.engine = create_engine('sqlite:///:memory:')
self.session_handler = ScopedSessionHandler(self.engine)
Base.metadata.create_all(self.engine)