def test_remove_all_items(self):
class Foo(Model):
pass
ds = datastore.DictDatastore()
mgr = Manager(ds, model=Foo)
key1 = Key('/foo:bar1')
key2 = Key('/foo:bar2')
instance1 = Foo.withData({'key': str(key1), 'foo': 'bar1'})
instance2 = Foo.withData({'key': str(key2), 'foo': 'bar2'})
# put in mgr
mgr.put(instance1)
mgr.put(instance2)
self.assertTrue(mgr.contains(key1))
self.assertTrue(ds.contains(key1))
self.assertTrue(mgr.contains(key2))
self.assertTrue(ds.contains(key2))
# delete all
mgr.remove_all_items()
self.assertFalse(mgr.contains(key1))
self.assertFalse(ds.contains(key1))
self.assertFalse(mgr.contains(key2))
self.assertFalse(ds.contains(key2))
def test_construct_with_model_option(self):
class Foo(Model):
pass
ds = datastore.DictDatastore()
mgr = Manager(ds, model=Foo)
self.assertTrue(mgr.model is Foo)
def test_query_returns_results(self):
class Foo(Model):
def __eq__(self, other):
return self.data == other.data
ds = datastore.DictDatastore()
mgr = Manager(ds, model=Foo)
instance1 = Foo.withData({'key': '/foo:bar1', 'foo': 'bar1'})
instance2 = Foo.withData({'key': '/foo:bar2', 'foo': 'bar2'})
mgr.put(instance1)
mgr.put(instance2)
# Query all on the manager
results = list(mgr.query())
self.assertEqual(len(results), 2)
# Query with filter
results = list(mgr.query(Query().filter('foo', '=', 'bar1')))
self.assertEqual(len(results), 1)
self.assertEqual(results[0], instance1)
results = list(mgr.query(Query().filter('foo', '=', 'bar2')))
self.assertEqual(len(results), 1)
self.assertEqual(results[0], instance2)
def test_key(self):
class Foo(Model): pass
ds = datastore.DictDatastore()
mgr = CollectionManager(ds)
mgr.model = Foo
self.assertEqual(mgr.instance_key('bar'), Key('/foo:bar'))
def test_construct_with_model_option(self):
class Foo(Model):
pass
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds, model=Foo)
self.assertTrue(ods.model is Foo)
def test_get_constructs_model(self):
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds)
key = Key('/model:foo')
dds.put(key, {'key': str(key), 'foo': 'bar'})
instance = ods.get(key)
self.assertTrue(isinstance(instance, ObjectDatastore.model))
def test_collection_key(self):
class Foo(Model): pass
ds = datastore.DictDatastore()
mgr = CollectionManager(ds)
mgr.model = Foo
self.assertEqual(mgr.collection_key, Key('/foo'))
def test_get_constructs_model(self):
ds = datastore.DictDatastore()
mgr = Manager(ds)
key = Key('/model:bar')
data = {'key': str(key), 'foo': 'bar'}
ds.put(key, data)
instance = mgr.get('bar')
self.assertTrue(isinstance(instance, Manager.model))
self.assertEqual(instance.data, data)
def test_get_constructs_model_with_data_attr(self):
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds)
key = Key('/model:foo')
data = {'key': str(key), 'foo': 'bar'}
dds.put(key, data)
instance = ods.get(key)
self.assertEqual(instance.data, data)
self.assertFalse(instance.data is data)
def test_put_stores_model_data_copy(self):
ds = datastore.DictDatastore()
mgr = Manager(ds)
key = Key('/model:bar')
instance = Model.withData({'key': str(key), 'foo': 'bar'})
mgr.put(instance)
data = ds.get(key)
self.assertFalse(instance.data is data)
self.assertEqual(instance.data, data)
def test_put_stores_model_data_copy(self):
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds)
key = Key('/model:foo')
instance = Model.withData({'key': str(key), 'foo': 'bar'})
ods.put(key, instance)
data = dds.get(key)
self.assertEqual(instance.data, data)
self.assertFalse(instance.data is data)
def test_put_adds_to_collection(self):
ds = datastore.DictDatastore()
mgr = CollectionManager(ds)
key = Key('/model:bar')
instance = Model.withData({'key': str(key), 'foo': 'bar'})
self.assertEqual(list(mgr.collection.keys), [])
mgr.put(instance)
self.assertEqual(list(mgr.collection.keys), [instance.key])
def test_get_constructs_model_option(self):
class Foo(Model):
pass
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds, model=Foo)
key = Key('/foo:foo')
dds.put(key, {'key': str(key), 'foo': 'bar'})
instance = ods.get(key)
self.assertTrue(isinstance(instance, ObjectDatastore.model))
self.assertTrue(isinstance(instance, Foo))
def test_get_constructs_model_with_model(self):
class Foo(Model): pass
ds = datastore.DictDatastore()
mgr = Manager(ds, model=Foo)
key = Key('/foo:bar')
data = {'key': str(key), 'foo': 'bar'}
ds.put(key, data)
instance = mgr.get('bar')
self.assertTrue(isinstance(instance, Manager.model))
self.assertEqual(instance.data, data)
def test_put_stores_model_data_copy_with_model(self):
class Foo(Model): pass
ds = datastore.DictDatastore()
mgr = Manager(ds, model=Foo)
key = Key('/foo:bar')
instance = Foo.withData({'key': str(key), 'foo': 'bar'})
mgr.put(instance)
data = ds.get(key)
self.assertFalse(instance.data is data)
self.assertEqual(instance.data, data)
def test_put_stores_model_data_with_key(self):
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds)
key = Key('/model:foo')
data = {'key': str(key), 'foo': 'bar'}
instance = Model.withData(data)
self.assertTrue('key' in data)
self.assertTrue('key' in instance.data)
ods.put(key, instance)
data = dds.get(key)
self.assertTrue('key' in data)
self.assertEqual(data['key'], '/model:foo')
def test_delete_and_contains_work(self):
ds = datastore.DictDatastore()
mgr = Manager(ds)
key = Key('/model:bar')
data = {'key': str(key), 'foo': 'bar'}
instance = Model.withData(data)
# put in mgr, delete from mgr
mgr.put(instance)
self.assertTrue(mgr.contains(key))
self.assertTrue(ds.contains(key))
mgr.delete(key)
self.assertFalse(mgr.contains(key))
self.assertFalse(ds.contains(key))
# put in mgr, delete from ds
mgr.put(instance)
self.assertTrue(mgr.contains(key))
self.assertTrue(ds.contains(key))
ds.delete(key)
self.assertFalse(mgr.contains(key))
self.assertFalse(ds.contains(key))
# put in ds, delete from mgr
ds.put(key, data)
self.assertTrue(mgr.contains(key))
self.assertTrue(ds.contains(key))
mgr.delete(key)
self.assertFalse(mgr.contains(key))
self.assertFalse(ds.contains(key))
# put in ds, delete from mgr
ds.put(key, data)
self.assertTrue(mgr.contains(key))
self.assertTrue(ds.contains(key))
ds.delete(key)
self.assertFalse(mgr.contains(key))
self.assertFalse(ds.contains(key))
def test_delete_and_contains_work(self):
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds)
key = Key('/model:foo')
data = {'key': str(key), 'foo': 'bar'}
instance = Model.withData(data)
# put in ods, delete from ods
ods.put(key, instance)
self.assertTrue(ods.contains(key))
self.assertTrue(dds.contains(key))
ods.delete(key)
self.assertFalse(ods.contains(key))
self.assertFalse(dds.contains(key))
# put in ods, delete from dds
ods.put(key, instance)
self.assertTrue(ods.contains(key))
self.assertTrue(dds.contains(key))
dds.delete(key)
self.assertFalse(ods.contains(key))
self.assertFalse(dds.contains(key))
# put in dds, delete from ods
dds.put(key, data)
self.assertTrue(ods.contains(key))
self.assertTrue(dds.contains(key))
ods.delete(key)
self.assertFalse(ods.contains(key))
self.assertFalse(dds.contains(key))
# put in dds, delete from dds
dds.put(key, data)
self.assertTrue(ods.contains(key))
self.assertTrue(dds.contains(key))
dds.delete(key)
self.assertFalse(ods.contains(key))
self.assertFalse(dds.contains(key))
def test_query_returns_instances(self):
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds)
key = Key('/model:foo')
instance = Model.withData({'key': str(key), 'foo': 'bar'})
ods.put(key, instance)
key = Key('/model:bar')
instance = Model.withData({'key': str(key), 'foo': 'bar'})
ods.put(key, instance)
query = datastore.Query(Key('/model'))
query.order('-key')
results = list(ods.query(query))
self.assertEqual(len(results), 2)
self.assertTrue(isinstance(results[0], Model))
self.assertTrue(isinstance(results[1], Model))
self.assertEqual(results[0].key, Key('/model:foo'))
self.assertEqual(results[1].key, Key('/model:bar'))
def test_collection(self):
ds = datastore.DictDatastore()
mgr = CollectionManager(ds)
self.assertTrue(isinstance(mgr.collection, Collection))
self.assertEqual(mgr.collection.key, Key('/model'))
def test_query_is_implemented(self):
dds = datastore.DictDatastore()
ods = ObjectDatastore(dds)
ods.query(datastore.Query(Key('/model')))
