示例#1
0
    def test_single_inverse_link(self):
        """
		Can resolve a single link.
		"""
        created_bazes = []
        baz_ids = []
        for i in range(0, 3):
            baz = {'name': 'Baz#%d' % i, '_id': '%d' % i}
            created_bazes.append(baz)
            baz_ids.append(baz['_id'])

        foo = {'_id': '123', 'bazes': baz_ids}

        foos = api.interfaces['foos']
        bazes = api.interfaces['bazes']
        foos.storage = Storage()
        bazes.storage = Storage()
        foos.storage.get = Mock(return_value=[foo])
        bazes.storage.get_by_id = Mock(return_value=created_bazes[0])

        linked_foo = bazes.link(baz_ids[0], 'foo')
        bazes.storage.get_by_id.assert_called_once_with(Baz, baz_ids[0])
        foos.storage.get.assert_called_once_with(Foo,
                                                 filter={'bazes': baz_ids[0]},
                                                 limit=1)
        self.assertEquals(linked_foo, foo)
示例#2
0
    def test_single_link_get_embedded(self):
        """
		Embedded links are included when fetching the referencing item.
		"""

        foo = {'_id': '123', 'stuff': 'foo'}
        bar = {'_id': '321', 'embedded_foo': '123'}

        foos = api.interfaces['foos']
        bars = api.interfaces['bars']
        foos.storage = Storage()
        bars.storage = Storage()
        foos.storage.get_by_id = Mock(return_value=foo)
        bars.storage.get_by_id = Mock(return_value=bar)

        bar = bars.get('321')
        self.assertEquals(bar['embedded_foo'], foo)
示例#3
0
    def test_single_link(self):
        """
		Can get a link through a link.
		"""
        foo = {'_id': '123', 'stuff': 'foo'}
        bar = {'_id': '321', 'foo': '123'}

        foos = api.interfaces['foos']
        bars = api.interfaces['bars']
        foos.storage = Storage()
        bars.storage = Storage()
        foos.storage.get_by_id = Mock(return_value=foo)
        bars.storage.get_by_id = Mock(return_value=bar)

        bars = api.interfaces['bars']

        linked_foo = bars.link('321', 'foo')
        self.assertEquals(linked_foo, foo)
        bars.storage.get_by_id.assert_called_once_with(Bar, '321')
        foos.storage.get_by_id.assert_called_once_with(Foo, '123')
示例#4
0
    def test_multiple_link_get_embedded(self):
        """
		Embedded link list is included when fetching the referencing item.
		"""
        created_bazes = []
        baz_ids = []
        for i in range(0, 3):
            baz = {'name': 'Baz#%d' % i, '_id': '%d' % i}
            created_bazes.append(baz)
            baz_ids.append(baz['_id'])

        foo = {'_id': '123', 'embedded_bazes': baz_ids}

        foos = api.interfaces['foos']
        bazes = api.interfaces['bazes']
        foos.storage = Storage()
        bazes.storage = Storage()
        foos.storage.get_by_id = Mock(return_value=foo)
        bazes.storage.get_by_ids = Mock(return_value=created_bazes)

        fetched_foo = foos.get(foo['_id'])
        self.assertEquals(fetched_foo['embedded_bazes'], created_bazes)
示例#5
0
    def test_pass(self):
        """
        Should do nothing special when initialized with a well-defined model
        """
        model = Model(storage=Storage())

        class Foo(model.Entity):
            bar = Link('Bar')

        class Bar(model.Entity):
            foos = ListOf(Link(Foo))

        Foo.get_link('bar')
        Bar.get_link('foos')
示例#6
0
    def test_fail_add_to_frozen(self):
        """
        Can't add an entity to a frozen model
        """
        model = Model(storage=Storage())

        class Foo(model.Entity):
            pass

        model.freeze()

        with self.assertRaises(Exception):

            class Bar(model.Entity):
                pass
示例#7
0
import unittest
import json
import msgpack
from mock import Mock
import urllib
from flask import Flask
from cellardoor import errors
from cellardoor.api import API
from cellardoor.wsgi.flask_integration import create_blueprint
from cellardoor.model import Model, Entity, Text, Link, ListOf
from cellardoor.storage import Storage
from cellardoor.api.interface import ALL, LIST, GET, CREATE

model = Model(storage=Storage())
api = API(model)


class Foo(model.Entity):
    name = Text(required=True)
    bar = Link('Bar')
    bazes = ListOf(Link('Baz'))


class Bar(model.Entity):
    pass


class Baz(model.Entity):
    pass

示例#8
0
 def get_interface(self, name, storage=None):
     if storage is None:
         storage = Storage()
     interface = api.interfaces[name]
     interface.set_storage(storage)
     return interface
示例#9
0
 def setUp(self):
     storage = Storage()
     model.storage = storage
     for interface in api.interfaces.values():
         interface.set_storage(storage)
示例#10
0
from cellardoor.storage import Storage
from cellardoor import errors
from cellardoor.authorization import ObjectProxy

identity = ObjectProxy('identity')
item = ObjectProxy('item')


class CopyingMock(Mock):
    def __call__(self, *args, **kwargs):
        args = deepcopy(args)
        kwargs = deepcopy(kwargs)
        return super(CopyingMock, self).__call__(*args, **kwargs)


storage = Storage()
model = Model(storage=storage)
api = API(model)


class Foo(model.Entity):
    stuff = Text(required=True)
    optional_stuff = Text()
    bars = InverseLink('Bar', 'foo')
    bazes = ListOf(Link('Baz'))
    embedded_bazes = ListOf(Link('Baz', embeddable=True))
    embedded_foos = ListOf(
        Link('Foo',
             embeddable=True,
             embed_by_default=False,
             embedded_fields=('stuff', )))
示例#11
0
import unittest
from mock import Mock
from cellardoor import errors
from cellardoor.api import API, StandardOptionsMixin, InterfaceProxy, FilterProxy, LinkProxy
from cellardoor.api.methods import ALL
from cellardoor.storage import Storage
from cellardoor.model import Model, Entity

storage = Storage()
storage.create = Mock()
model = Model(storage=storage)
api = API(model)

class Foo(model.Entity):
	pass
	
class Foos(api.Interface):
	entity = Foo
	method_authorization = {
		ALL: None
	}


class TestStandardOptionsMixin(unittest.TestCase):
	
	def test_has_options(self):
		options = StandardOptionsMixin()
		self.assertTrue(hasattr(options, '_options'))
		self.assertEquals(options._options, {})
		
		
示例#12
0
	def test_abstract_storage(self):
		storage = Storage()
		
		with self.assertRaises(NotImplementedError):
			storage.get(None)
			
		with self.assertRaises(NotImplementedError):
			storage.get_by_ids(None, None)
			
		with self.assertRaises(NotImplementedError):
			storage.get_by_id(None, None)
			
		with self.assertRaises(NotImplementedError):
			storage.create(None, None)
			
		with self.assertRaises(NotImplementedError):
			storage.update(None, None, None)
			
		with self.assertRaises(NotImplementedError):
			storage.delete(None, None)
			
		with self.assertRaises(NotImplementedError):
			storage.check_filter(None, None, None)