def test_cache_gets_change_from_db(self):
dog = Dog(name="woofer")
self.db.put(dog)
with buffered_db(self.db) as dbc:
fetched = dbc.get(dog.key)
self.assertTrue(fetched is not None)
self.assertNotEqual(id(dog), id(fetched))
fetched_again = dbc.get(dog.key)
self.assertTrue(fetched_again is not None)
self.assertEqual(id(fetched), id(fetched_again))
dog.name = "fly"
self.db.put(dog)
fetched_yet_again = dbc.get(dog.key)
self.assertTrue(fetched_yet_again is not None)
self.assertEqual(id(fetched), id(fetched_yet_again))
self.assertEqual(fetched_yet_again.name, 'fly')
fetched_yet_again.name = "bluebottle"
db_fetched = self.db.get(dog.key)
self.assertEqual(db_fetched.name, 'fly')
db_fetched = self.db.get(dog.key)
self.assertEqual(db_fetched.name, 'fly')
def test_make_a_validator_from_modules(self):
mapper = ClassMapper([], modules=[test01])
validator = ModelValidator(classes=[Dog, Cat, Person, JackRussell])
self.db = CouchDBWrapper(mapper, COUCHDB_URL, COUCHDB_NAME, reset=True, validator=validator)
self.db.update_designs()
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=4)
cat.save(self.db)
self.assertEqual(cat.owner, paul)
self.assertEqual(cat.owner.name, "paul")
#missing legs
cat = Cat(name="puss", owner_id=paul.key)
self.assertRaises(FamValidationError, cat.save, self.db)
#additional properties
def failing_cat():
cat = Cat(name="puss", owner_id=paul.key, legs=2, collar="green")
self.assertRaises(FamValidationError, failing_cat)
dog = Dog(name="fly")
self.db.put(dog)
dog.tail = "long"
self.db.put(dog)
self.db.session.close()
def test_uniqueness(self):
paul = Person(name="paul")
self.db.put(paul)
dog1 = Dog(name="rufus", owner_id=paul.key, kennel_club_membership="123456")
dog1.save(self.db)
def test_sync_down_since(self):
paul = Person.create(self.firestore, name="paul")
sol = Person.create(self.firestore, name="sol")
dog1 = Dog.create(self.firestore, name="woofer", owner=paul)
dog2 = Dog.create(self.firestore, name="tiny", owner=paul)
dog3 = Dog.create(self.firestore, name="fly", owner=paul)
dogs_ref = self.firestore.db.collection("dog")
syncer = FirestoreSyncer(self.couchdb, self.firestore)
syncer.add_query(dogs_ref.where("owner_id", "==", paul.key))
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 0)
changed = syncer.sync_down()
self.assertEqual(len(changed), 3)
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 3)
dog3.update({"name":"jelly"})
changed = syncer.sync_down()
print(changed)
self.assertEqual(len(changed), 1)
updated = self.couchdb.get(dog3.key)
self.assertEqual(updated.name, "jelly")
def test_uniqueness_delete(self):
paul = Person(name="paul")
self.db.put(paul)
dog1 = Dog.create(self.db, name="rufus", owner_id=paul.key, kennel_club_membership="123456")
dog1.delete(self.db)
dog2 = Dog.create(self.db, name="another", owner_id=paul.key, kennel_club_membership="123456")
def test_make_an_object_saved(self):
dog = Dog(name="woofer")
dog.save(self.db)
self.assertEqual(dog.namespace, NAMESPACE)
self.assertEqual(dog.type, "dog")
self.assertEqual(dog.name, "woofer")
self.assertEqual(dog.__class__, Dog)
self.assertNotEqual(dog.key, None)
def test_make_an_object_saved(self):
dog = Dog(name="woofer")
dog.save(self.db)
self.assertEqual(dog.namespace, NAMESPACE)
self.assertEqual(dog.type, "dog")
self.assertEqual(dog.name, "woofer")
self.assertEqual(dog.__class__, Dog)
self.assertNotEqual(dog.key, None)
def test_uniqueness_delete(self):
self.clear_db()
paul = Person(name="paul")
self.db.put(paul)
dog1 = Dog.create(self.db, name="rufus", owner_id=paul.key, kennel_club_membership="123456")
dog1.delete(self.db)
dog2 = Dog.create(self.db, name="another", owner_id=paul.key, kennel_club_membership="123456")
def test_get_unique(self):
self.clear_db()
paul = Person(name="paul")
self.db.put(paul)
dog1 = Dog.create(self.db, name="rufus", owner_id=paul.key, kennel_club_membership="123456")
dog2 = Dog.get_unique_instance(self.db, "kennel_club_membership", "123456")
self.assertIsNotNone(dog2)
self.assertTrue(dog2.kennel_club_membership == "123456")
def test_get_unique(self):
paul = Person(name="paul")
self.db.put(paul)
dog1 = Dog.create(self.db, name="rufus", owner_id=paul.key, kennel_club_membership="123456")
dog2 = Dog.get_unique_instance(self.db, "kennel_club_membership", "123456")
self.assertIsNotNone(dog2)
self.assertTrue(dog2.kennel_club_membership == "123456")
def test_refs_with_other_inheritance(self):
paul = Monarch(name="paul")
self.db.put(paul)
jack = Dog()
jack.owner = paul
jack.name = "jack"
self.db.put(jack)
dogs = list(paul.dogs)
self.assertEqual(dogs[0], jack)
def test_refs_with_other_inheritance(self):
paul = Monarch(name="paul")
self.db.put(paul)
jack = Dog()
jack.owner = paul
jack.name = "jack"
self.db.put(jack)
dogs = list(paul.dogs)
self.assertEqual(dogs[0], jack)
def test_make_an_object_and_refresh(self):
dog = Dog.create(self.db, name="woofer")
dog2 = Dog.get(self.db, dog.key)
self.assertIsNotNone(dog2)
time.sleep(1)
self.db.refresh()
dog3 = Dog.create(self.db, name="another")
dog4 = Dog.get(self.db, dog3.key)
self.assertIsNotNone(dog4)
def test_new_callbacks(self):
with patch.object(Dog, 'pre_save_new_cb', return_value=None) as mock_pre_new:
dog = Dog(name="woofer")
self.db.put(dog)
mock_pre_new.assert_called_once_with(self.db)
with patch.object(Dog, 'post_save_new_cb', return_value=None) as mock_post_new:
dog = Dog(name="woofer")
self.db.put(dog)
mock_post_new.assert_called_once_with(self.db)
def test_batch_put_delayed(self):
with FirestoreBatchContext(self.db) as bdb:
dog = Dog(name="woofer")
bdb.put(dog)
got = Dog.get(self.db, dog.key)
self.assertIsNone(got)
got = Dog.get(self.db, dog.key)
self.assertIsNotNone(got)
self.assertEqual(len(bdb.results), 1)
def test_batch_update(self):
with FirestoreBatchContext(self.db) as bdb:
dog = Dog(name="woofer")
bdb.put(dog)
dog.update({"name": "steve"})
got = Dog.get(self.db, dog.key)
self.assertIsNotNone(got)
self.assertEqual(got.name, "steve")
self.assertEqual(len(bdb.results), 2)
def test_uniqueness(self):
self.clear_db()
paul = Person(name="paul")
self.db.put(paul)
dog1 = Dog.create(self.db, name="rufus", owner_id=paul.key, kennel_club_membership="123456")
dog2 = Dog.create(self.db, name="fly", owner_id=paul.key)
# raises if setting one value
self.assertRaises(FamUniqueError, dog2.update, {"kennel_club_membership": "123456"})
self.assertIsNone(dog2.kennel_club_membership)
# raises if creating a new one
self.assertRaises(FamUniqueError, Dog.create, self.db, name="steve", owner_id=paul.key, kennel_club_membership="123456")
def test_updates_from_dict(self):
self.clear_db()
paul = Person.create(self.db, name="paul")
dog1 = Dog.create(self.db, name="rufus", owner_id=paul.key, kennel_club_membership="123456")
attrs = {
"name":"joe",
"kennel_club_membership": "9876543"
}
dog1.update(attrs)
dog2 = Dog.get(self.db, dog1.key)
self.assertTrue(dog2.kennel_club_membership == "9876543")
def test_updates_from_dict(self):
paul = Person.create(self.db, name="paul")
dog1 = Dog.create(self.db,
name="rufus",
owner_id=paul.key,
kennel_club_membership="123456")
attrs = {"name": "joe", "kennel_club_membership": "9876543"}
dog1.update(attrs)
dog2 = Dog.get(self.db, dog1.key)
self.assertTrue(dog2.kennel_club_membership == "9876543")
def test_uniqueness(self):
paul = Person(name="paul")
self.db.put(paul)
dog1 = Dog.create(self.db, name="rufus", owner_id=paul.key, kennel_club_membership="123456")
dog2 = Dog.create(self.db, name="fly", owner_id=paul.key)
# raises if setting one value
self.assertRaises(FamUniqueError, dog2.update, {"kennel_club_membership": "123456"})
self.assertIsNone(dog2.kennel_club_membership)
# raises if creating a new one
self.assertRaises(FamUniqueError, Dog.create, self.db, name="steve", owner_id=paul.key, kennel_club_membership="123456")
def test_delete_dog_refs(self):
paul = Person(name="paul")
self.db.put(paul)
dog = Dog(name="rufus", owner_id=paul.key)
self.db.put(dog)
key = dog.key
dog2 = Dog(name="fly", owner_id=paul.key)
self.db.put(dog2)
reviveddog1 = Dog.get(self.db, key)
self.assertTrue(reviveddog1 is not None)
self.db.delete(paul)
reviveddog2 = Dog.get(self.db, key)
self.assertTrue(reviveddog2 is not None)
def test_delete_dog_refs(self):
paul = Person(name="paul")
paul.save(self.db)
dog = Dog(name="rufus", owner_id=paul.key)
dog.save(self.db)
key = dog.key
dog2 = Dog(name="fly", owner_id=paul.key)
dog2.save(self.db)
reviveddog1 = Dog.get(self.db, key)
self.assertTrue(reviveddog1 is not None)
paul.delete(self.db)
reviveddog2 = Dog.get(self.db, key)
self.assertTrue(reviveddog2 is not None)
def test_query_generator(self):
paul = Person.create(self.firestore, name="paul")
dog1 = Dog.create(self.firestore, name="woofer", owner=paul)
dog2 = Dog.create(self.firestore, name="tiny", owner=paul)
dog3 = Dog.create(self.firestore, name="fly", owner=paul)
dogs_ref = self.firestore.db.collection("dog")
q = dogs_ref.where(u"owner_id", u"==", paul.key)
dogs = self.firestore.query_items(q, batch_size=1)
dogs_list = list(dogs)
self.assertTrue(isinstance(dogs_list[0], Dog))
self.assertEqual(len(dogs_list), 3)
def test_query_generator(self):
paul = Person.create(self.firestore, name="paul")
dog1 = Dog.create(self.firestore, name="woofer", owner=paul)
dog2 = Dog.create(self.firestore, name="tiny", owner=paul)
dog3 = Dog.create(self.firestore, name="fly", owner=paul)
dogs_ref = self.firestore.db.collection("dog")
q = dogs_ref.where(u"owner_id", u"==", paul.key)
dogs = self.firestore.query_items(q, batch_size=1)
dogs_list = list(dogs)
self.assertTrue(isinstance(dogs_list[0], Dog))
self.assertEqual(len(dogs_list), 3)
def test_delete_dog_to_refs(self):
paul = Person(name="paul")
self.db.put(paul)
dog = Dog(name="rufus", owner_id=paul.key)
self.db.put(dog)
key = dog.key
dog2 = Dog(name="fly", owner_id=paul.key)
self.db.put(dog2)
self.assertTrue(dog2.owner is not None)
key = paul.key
self.db.delete(dog)
revivedpaul = self.db.get(key)
self.assertTrue(revivedpaul is None)
refresheddog2 = Dog.get(self.db, dog2.key)
self.assertTrue(refresheddog2.owner is None)
def test_sync_up(self):
paul = Person.create(self.firestore, name="paul")
sol = Person.create(self.firestore, name="sol")
dog1 = Dog.create(self.firestore, name="woofer", owner=paul)
dog2 = Dog.create(self.firestore, name="tiny", owner=paul)
dog3 = Dog.create(self.firestore, name="fly", owner=paul)
dogs_ref = self.firestore.db.collection("dog")
syncer = FirestoreSyncer(self.couchdb, self.firestore)
syncer.add_query(dogs_ref.where("owner_id", "==", paul.key))
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 0)
syncer.sync_down()
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 3)
dog4 = Dog.create(self.couchdb, name="di", owner_id=paul.key)
dog5 = Dog.create(self.couchdb, name="stevie", owner_id=paul.key)
syncer.sync_up()
dogs = list(paul.dogs)
self.assertEqual(len(dogs), 5)
def test_sync_up(self):
paul = Person.create(self.firestore, name="paul")
sol = Person.create(self.firestore, name="sol")
dog1 = Dog.create(self.firestore, name="woofer", owner=paul)
dog2 = Dog.create(self.firestore, name="tiny", owner=paul)
dog3 = Dog.create(self.firestore, name="fly", owner=paul)
dogs_ref = self.firestore.db.collection("dog")
syncer = FirestoreSyncer(self.couchdb, self.firestore)
syncer.add_query(dogs_ref.where("owner_id", "==", paul.key))
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 0)
syncer.sync_down()
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 3)
dog4 = Dog.create(self.couchdb, name="di", owner_id=paul.key)
dog5 = Dog.create(self.couchdb, name="stevie", owner_id=paul.key)
syncer.sync_up()
dogs = list(paul.dogs)
self.assertEqual(len(dogs), 5)
def test_query_views(self):
views = FamWriteBufferViews(self.mapper)
paul = Person(name="paul")
dog = Dog(name="woofer", owner=paul)
views.index_obj(dog)
obj = views.query_view("glowinthedark.co.uk/test/person_dogs",
key=paul.key)
self.assertEqual(obj, [dog])
def test_cache_saves(self):
with buffered_db(self.db) as dbc:
dog = Dog(name="woofer")
dbc.put(dog)
got = self.db.get(dog.key)
self.assertTrue(got is not None)
def test_update_callbacks(self):
with patch.object(Dog, 'pre_save_update_cb', return_value=None) as mock_pre_update:
dog = Dog(name="woofer")
self.db.put(dog)
old_properties = deepcopy(dog._properties)
mock_pre_update.assert_not_called()
dog.name = "fly"
self.db.put(dog)
mock_pre_update.assert_called_once_with(self.db, old_properties)
with patch.object(Dog, 'post_save_update_cb', return_value=None) as mock_post_update:
dog = Dog(name="woofer")
self.db.put(dog)
mock_post_update.assert_not_called()
dog.name = "fly"
self.db.put(dog)
mock_post_update.assert_called_once_with(self.db)
def test_cache_gets(self):
# doesnt save until were done
with buffered_db(self.db) as dbc:
dog = Dog(name="woofer")
dbc.put(dog)
fetched = dbc.get(dog.key)
self.assertTrue(fetched is not None)
self.assertEqual(id(dog), id(fetched))
def test_delete_dog_to_refs(self):
paul = Person(name="paul")
paul.save(self.db)
dog = Dog(name="rufus", owner_id=paul.key)
dog.save(self.db)
key = dog.key
dog2 = Dog(name="fly", owner_id=paul.key)
dog2.save(self.db)
self.assertTrue(dog2.owner is not None)
key = paul.key
dog.delete(self.db)
revivedpaul = self.db.get(key)
self.assertTrue(revivedpaul is None)
refresheddog2 = Dog.get(self.db, dog2.key)
self.assertTrue(refresheddog2.owner is None)
def test_make_views(self):
views = FamWriteBufferViews(self.mapper)
paul = Person(name="paul")
dog = Dog(name="woofer", owner=paul)
views.index_obj(dog)
self.assertTrue(
views.indexes.get("glowinthedark_co_uk_test_person_dogs") != None)
self.assertTrue(views.indexes["glowinthedark_co_uk_test_person_dogs"][
paul.key][dog.key] == dog)
def test_refs_from(self):
with buffered_db(self.db) as dbc:
person = Person(name="paul")
dbc.put(person)
dog = Dog(name="woofer", owner=person)
dbc.put(dog)
self.assertEqual(person.dogs, [dog])
def test_cache_doesnt_save(self):
# doesnt save until were done
with buffered_db(self.db) as dbc:
dog = Dog(name="woofer")
dbc.put(dog)
got = self.db.get(dog.key)
self.assertTrue(got is None)
got = self.db.get(dog.key)
self.assertTrue(got is not None)
def test_delete_dog_refs(self):
paul = Person(name="paul")
paul.save(self.db)
dog = Dog(name="rufus", owner_id=paul.key)
dog.save(self.db)
key = dog.key
dog2 = Dog(name="fly", owner_id=paul.key)
dog2.save(self.db)
reviveddog1 = Dog.get(self.db, key)
self.assertTrue(reviveddog1 is not None)
paul.delete(self.db)
reviveddog2 = Dog.get(self.db, key)
self.assertTrue(reviveddog2 is not None)
def test_sync_down_single(self):
paul = Person.create(self.firestore, name="paul")
sol = Person.create(self.firestore, name="sol")
dog1 = Dog.create(self.firestore, name="woofer", owner=paul)
syncer = FirestoreSyncer(self.couchdb, self.firestore)
dog1_ref = self.firestore.db.collection("dog").document(dog1.key)
syncer.add_doc_ref(dog1_ref)
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 0)
syncer.sync_down()
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 1)
def test_sync_down_single(self):
paul = Person.create(self.firestore, name="paul")
sol = Person.create(self.firestore, name="sol")
dog1 = Dog.create(self.firestore, name="woofer", owner=paul)
syncer = FirestoreSyncer(self.couchdb, self.firestore)
dog1_ref = self.firestore.db.collection("dog").document(dog1.key)
syncer.add_doc_ref(dog1_ref)
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 0)
syncer.sync_down()
dogs = Dog.all(self.couchdb)
dogs_list = list(dogs)
self.assertEqual(len(dogs_list), 1)
def test_delete_dog_refs(self):
paul = Person(name="paul")
paul.save(self.db)
dog = Dog(name="rufus", owner_id=paul.key)
dog.save(self.db)
key = dog.key
dog2 = Dog(name="fly", owner_id=paul.key)
dog2.save(self.db)
reviveddog1 = self.db.get(key)
self.assertNotEqual(reviveddog1, None)
paul.delete(self.db)
reviveddog2 = self.db.get(key)
self.assertNotEqual(reviveddog2, None)
def test_saves_putted(self):
dog = Dog(name="woofer")
self.db.put(dog)
with buffered_db(self.db) as dbc:
fetched = dbc.get(dog.key)
fetched.name = "bluebottle"
dbc.put(fetched)
db_fetched = self.db.get(dog.key)
self.assertEqual(db_fetched.name, 'bluebottle')
def test_cache_gets_from_db(self):
dog = Dog(name="woofer")
self.db.put(dog)
with buffered_db(self.db) as dbc:
fetched = dbc.get(dog.key)
self.assertTrue(fetched is not None)
self.assertNotEqual(id(dog), id(fetched))
fetched_again = dbc.get(dog.key)
self.assertEqual(id(fetched), id(fetched_again))
def test_data_base_id(self):
dog = Dog.create(self.db, name="woofer")
dog_id = dog.key
self.assertTrue(dog.key is not None)
doc_ref = self.db.db.collection("dog").document(dog_id)
doc = doc_ref.get()
as_dict = doc.to_dict()
# self.assertTrue("_id" not in as_dict)
self.assertTrue("type" not in as_dict)
self.assertTrue("namespace" not in as_dict)
got_dog = Dog.get(self.db, dog_id)
self.assertTrue(got_dog.key == dog_id)
self.assertTrue(got_dog.namespace == dog.namespace)
self.assertTrue(got_dog.type == "dog")
def test_data_base_id(self):
dog = Dog.create(self.db, name="woofer")
dog_id = dog.key
self.assertTrue(dog.key is not None)
doc_ref = self.db.db.collection("dog").document(dog_id)
doc = doc_ref.get()
as_dict = doc.to_dict()
# self.assertTrue("_id" not in as_dict)
self.assertTrue("type" not in as_dict)
self.assertTrue("namespace" not in as_dict)
got_dog = Dog.get(self.db, dog_id)
self.assertTrue(got_dog.key == dog_id)
self.assertTrue(got_dog.namespace == dog.namespace)
self.assertTrue(got_dog.type == "dog")
def test_ref_from_multiple_index(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
dog = Dog(name="fly", owner=paul)
self.db.put(dog)
cats = list(paul.cats)
self.assertEqual(len(cats), 1)
dogs = list(paul.dogs)
self.assertEqual(len(dogs), 1)
animals = list(paul.animals)
self.assertEqual(len(animals), 2)
def test_iterate_dogs(self):
me = Person(name="paul")
self.db.put(me)
for i in range(500):
dog = Dog(name="dog_%s" % i, owner=me)
self.db.put(dog)
counter = 0
for dog in me.dogs:
counter += 1
self.assertEqual(counter, 500)
def test_views_keys(self):
views = FamWriteBufferViews(self.mapper)
paul = Person(name="paul")
dog = Dog(name="woofer", owner=paul)
views.index_obj(dog)
print("keys: ", views.indexes.keys())
self.assertEqual(
set(views.indexes.keys()), {
'glowinthedark_co_uk_test_person_animals',
'glowinthedark_co_uk_test_person_dogs', 'raw_all',
'glowinthedark_co_uk_test_dog_kennel_club_membership'
})
def test_uniqueness(self):
paul = Person(name="paul")
self.db.put(paul)
dog1 = Dog(name="rufus",
owner_id=paul.key,
kennel_club_membership="123456")
dog1.save(self.db)
time.sleep(1)
print(dog1.as_json())
dog2 = Dog(name="fly",
owner_id=paul.key,
kennel_club_membership="123456")
print(dog2.as_json())
# self.db.put(dog2)
self.assertRaises(FamUniqueError, self.db.put, dog2)
def test_delete_dog_refs(self):
paul = Person(name="paul")
paul.save(self.db)
dog = Dog(name="rufus", owner_id=paul.key)
dog.save(self.db)
key = dog.key
dog2 = Dog(name="fly", owner_id=paul.key)
dog2.save(self.db)
reviveddog1 = self.db.get(key)
self.assertNotEqual(reviveddog1, None)
paul.delete(self.db)
reviveddog2 = self.db.get(key)
self.assertNotEqual(reviveddog2, None)
def test_delete_callbacks(self):
with patch.object(Dog, 'pre_delete_cb', return_value=None) as mock_pre_delete:
dog = Dog(name="woofer")
self.db.put(dog)
mock_pre_delete.assert_not_called()
dog.name = "fly"
self.db.delete(dog)
mock_pre_delete.assert_called_once_with(self.db)
with patch.object(Dog, 'post_delete_cb', return_value=None) as mock_post_delete:
dog = Dog(name="woofer")
self.db.put(dog)
mock_post_delete.assert_not_called()
dog.name = "fly"
self.db.delete(dog)
mock_post_delete.assert_called_once_with(self.db)
def test_all(self):
dog = Dog(name="fly")
dog.save(self.db)
all = Dog.all(self.db)
self.assertEqual(len(all), 1)
def test_save(self):
dog = Dog(name="fly")
dog.save(self.db)
def test_get(self):
dog = Dog(name="fly")
dog.save(self.db)
dog_key = dog.key
got_dog = self.db.get(dog_key)
self.assertEqual(dog.name, got_dog.name)
def test_n1ql(self):
dog = Dog(name="fly")
dog.save(self.db)
dogs = self.db.n1ql('SELECT META(test).cas, META(test).id, * FROM test WHERE type="dog" and name="fly"')
def test_make_an_object_with_additional_properties(self):
dog = Dog(name="woofer", collar="leather")
dog.home = "hackney"
self.db.put(dog)
self.assertEqual(dog.home, "hackney")
def test_make_an_object2(self):
dog = Dog(name="woofer")
self.assertEqual(dog.talk(), "woof")
def test_update_fails_without_rev(self):
dog = Dog(name="fly")
dog.save(self.db)
dog.rev = None
dog.name = "jess"
self.assertRaises(FamResourceConflict, self.db.put, dog)
def test_update_dogfood(self):
dog = Dog(name="fly")
dog.food = "biscuits"
dog.save(self.db)
