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')))