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_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_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_ref_to(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
self.assertEqual(cat.owner, paul)
self.assertEqual(cat.owner.name, "paul")
def test_ref_to(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
self.assertEqual(cat.owner, paul)
self.assertEqual(cat.owner.name, "paul")
def test_make_a_validator(self):
mapper = ClassMapper([Dog, Cat, Person, JackRussell])
validator = ModelValidator(None,
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")
cat = Cat(name="puss", owner_id=paul.key)
self.assertRaises(FamValidationError, cat.save, self.db)
self.db.session.close()
def test_make_a_validator_from_modules(self):
mapper = ClassMapper([], modules=[test01])
validator = ModelValidator(mapper)
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_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_string_format(self):
mapper = ClassMapper([], modules=[test01])
validator = ModelValidator(mapper)
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")
cat = Cat(name="puss",
owner_id=paul.key,
legs=3,
email="*****@*****.**")
cat.save(self.db)
cat.email = "paulglowinthedark.co.uk"
self.assertRaises(FamValidationError, self.db.put, cat)
self.db.session.close()
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_get_cat(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
def test_get_cat(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
def test_make_an_object_saved_cas(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
self.assertEqual(cat.namespace, NAMESPACE)
self.assertEqual(cat.type, "cat")
self.assertNotEqual(cat.rev, None)
def test_make_an_object_saved_cas(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
self.assertEqual(cat.namespace, NAMESPACE)
self.assertEqual(cat.type, "cat")
self.assertNotEqual(cat.rev, None)
def test_refs_with_inheritance(self):
paul = Person(name="paul")
paul.save(self.db)
jack = JackRussell()
jack.owner_id = paul.key
jack.name = "jack"
jack.save(self.db)
self.assertEqual(list(paul.dogs)[0], jack)
def test_refs_with_inheritance(self):
paul = Person(name="paul")
paul.save(self.db)
jack = JackRussell()
jack.owner_id = paul.key
jack.name = "jack"
jack.save(self.db)
self.assertEqual(list(paul.dogs)[0], jack)
def test_ref_from(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key)
cat.save(self.db)
cat2 = Cat(name="puss", owner_id=paul.key)
cat2.save(self.db)
self.assertEqual(len(paul.cats), 2)
self.assertTrue(paul.cats[0] == cat or paul.cats[1] == cat)
def test_ref_from(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key)
cat.save(self.db)
cat2 = Cat(name="puss", owner_id=paul.key)
cat2.save(self.db)
self.assertEqual(len(paul.cats), 2)
self.assertTrue(paul.cats[0] == cat or paul.cats[1] == cat)
def test_update_cat_fails(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
cat.colour = "black"
cat.save(self.db)
def change_colour():
cat.colour = "white"
self.assertRaises(FamImmutableError, change_colour)
def test_null_values(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, colour=None)
self.assertTrue(cat.colour is None)
self.assertTrue(cat._properties["colour"] is None)
cat.save(self.db)
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
def test_delete_cat_refs(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
key = cat.key
cat2 = Cat(name="puss", owner_id=paul.key, legs=2)
cat2.save(self.db)
cats = list(paul.cats)
def test_update_cat(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
cat.name = "blackie"
cat.save(self.db)
self.assertEqual(cat.name, "blackie")
self.assertEqual(cat._properties["name"], "blackie")
self.assertFalse("name" in cat.__dict__.keys())
def test_update_cat(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
cat.name = "blackie"
cat.save(self.db)
self.assertEqual(cat.name, "blackie")
self.assertEqual(cat._properties["name"], "blackie")
self.assertFalse("name" in cat.__dict__.keys())
def test_update_cat_fails(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
cat.colour = "black"
cat.save(self.db)
def change_colour():
cat.colour = "white"
self.assertRaises(FamImmutableError, change_colour)
def test_delete_cat_refs(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key)
cat.save(self.db)
key = cat.key
cat2 = Cat(name="puss", owner_id=paul.key)
cat2.save(self.db)
revivedcat1 = self.db.get(key)
self.assertNotEqual(revivedcat1, None)
paul.delete(self.db)
revivedcat2 = self.db.get(key)
self.assertEqual(revivedcat2, 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 = self.db.get(key)
self.assertTrue(reviveddog1 is not None)
paul.delete(self.db)
reviveddog2 = self.db.get(key)
self.assertTrue(reviveddog2 is not None)
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_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_make_a_validator_from_modules(self):
validator = ModelValidator(modules=[test01])
#add validator to db
self.db.validator = validator
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")
cat = Cat(name="puss", owner_id=paul.key)
self.assertRaises(FamValidationError, cat.save, self.db)
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_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_delete_cat_refs(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
key = cat.key
cat2 = Cat(name="puss", owner_id=paul.key, legs=2)
cat2.save(self.db)
revivedcat1 = Cat.get(self.db, key)
self.assertTrue(revivedcat1 is not None)
paul.delete(self.db)
revivedcat2 = self.db.get(key)
self.assertTrue(revivedcat2 is None)
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)
# # print "*********** end ***************"
# class RefNameTests(unittest.TestCase):
#
# # this test that refs whos name doesnt end with _id fail
# def test_misnamed_ref_to_fails(self):
#
# def duff_import():
# from fam.tests.models import test02
# print(test02)
#
# self.assertRaises(FamError, duff_import)
def test_get_created_cat(self):
paul = Person(name="paul")
self.db.put(paul)
cat = Cat.create(self.db, name="whiskers", owner_id=paul.key, legs=2)
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
def test_make_a_validator_from_classes(self):
validator = ModelValidator(None, classes=[Cat, Person])
#add validator to db
self.db.validator = validator
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")
cat = Cat(name="puss", owner_id=paul.key)
self.assertRaises(FamValidationError, cat.save, self.db)
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_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_ref_to_with_object(self):
paul = Person(name="paul")
self.db.put(paul)
cat = Cat(name="whiskers", owner=paul, legs=2)
cat.save(self.db)
self.assertEqual(cat.owner, paul)
self.assertEqual(cat.owner.name, "paul")
catback = self.db.get(cat.key)
self.assertEqual(cat, catback)
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_make_a_validator(self):
mapper = ClassMapper([Dog, Cat, Person, JackRussell])
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")
cat = Cat(name="puss", owner_id=paul.key)
self.assertRaises(FamValidationError, cat.save, self.db)
self.db.session.close()
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_long_polling(self):
paul = Person(name="Paul")
self.db.put(paul)
cat1 = Cat(owner=paul, legs=4)
self.db.put(cat1)
cat2 = Cat(owner=paul, legs=3)
self.db.put(cat2)
three_legged_cats = self.db.view("animal_views/cat_legs", key=3)
self.assertEqual(len(three_legged_cats), 1)
self.assertEqual(three_legged_cats[0].key, cat2.key)
def test_ref_from(self):
paul = Person(name="paul")
self.db.put(paul)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
self.db.put(cat)
cat2 = Cat(name="puss", owner_id=paul.key, legs=2)
self.db.put(cat2)
cats = list(paul.cats)
self.assertEqual(len(cats), 2)
cats = list(paul.cats)
self.assertTrue(cats[0] == cat or cats[1] == cat)
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_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_cat_dd(self):
paul = Person(name="paul")
self.db.put(paul)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
self.db.put(cat)
key = cat.key
another = self.db.get(cat.key)
self.assertEqual(cat, another)
self.db.delete(cat)
revivedcat = self.db.get(key)
self.assertEqual(revivedcat, None)
def test_make_a_validator(self):
validator = ModelValidator(None)
validator.add_schema(test01.NAMESPACE, "cat", Cat)
validator.add_schema(test01.NAMESPACE, "person", Person)
#add validator to db
self.db.validator = validator
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")
cat = Cat(name="puss", owner_id=paul.key)
self.assertRaises(FamValidationError, cat.save, self.db)
def test_make_a_validator(self):
validator = ModelValidator()
validator.add_schema(test01.NAMESPACE, "cat", Cat)
validator.add_schema(test01.NAMESPACE, "person", Person)
#add validator to db
self.db.validator = validator
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")
cat = Cat(name="puss", owner_id=paul.key)
self.assertRaises(FamValidationError, cat.save, self.db)
def test_string_format(self):
mapper = ClassMapper([], modules=[test01])
validator = ModelValidator(modules=[test01])
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")
cat = Cat(name="puss", owner_id=paul.key, legs=3, email="*****@*****.**")
cat.save(self.db)
cat.email = "paulglowinthedark.co.uk"
self.assertRaises(FamValidationError, self.db.put, cat)
self.db.session.close()
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_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_included_refs_from_in_validator(self):
mapper = ClassMapper([], modules=[test01])
validator = ModelValidator(modules=[test01])
self.db = CouchDBWrapper(mapper, COUCHDB_URL, COUCHDB_NAME, reset=True, validator=validator)
self.db.update_designs()
paul = Person(name="paul")
paul.save(self.db)
paul_id = paul.key
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")
paul = Person.get(self.db, paul_id)
paul.save(self.db)
self.db.session.close()
def test_update_catfood(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
cat.save(self.db)
self.assertRaises(Exception, self.setcatfood)
