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_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_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_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_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_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_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_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_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_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_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_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 = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
self.db.delete(cat)
revivedcat = self.db.get(key)
self.assertEqual(revivedcat, None)
def test_query_view(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 = Cat.all_with_n_legs(self.db, 3)
self.assertEqual(len(three_legged_cats), 1)
self.assertEqual(three_legged_cats[0].key, cat2.key)
def test_update_cat_fails(self):
paul = Person(name="paul")
self.db.put(paul)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
self.db.put(cat)
cat.colour = "black"
self.db.put(cat)
def change_colour():
cat.colour = "white"
self.assertRaises(FamImmutableError, change_colour)
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_batch_puts_atomic(self):
try:
with FirestoreBatchContext(self.db) as bdb:
cat = Cat(name="blaze")
bdb.put(cat)
cat2 = Cat(name="muse", car="fiat")
bdb.put(cat2)
except Exception as e:
print(e)
got = Cat.get(self.db, cat.key)
self.assertIsNone(got)
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_update_cat(self):
paul = Person(name="paul")
self.db.put(paul)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
self.db.put(cat)
cat.name = "blackie"
self.db.put(cat)
self.assertEqual(cat.name, "blackie")
self.assertEqual(cat._properties["name"], "blackie")
self.assertFalse("name" in cat.__dict__.keys())
got = Cat.get(self.db, cat.key)
self.assertEqual(got.name, "blackie")
def test_delete_cat_refs(self):
paul = Person(name="paul")
self.db.put(paul)
cat = Cat(name="whiskers", owner_id=paul.key, legs=2)
self.assertTrue("dogs" not in cat.__class__.fields.items())
self.db.put(cat)
key = cat.key
cat2 = Cat(name="puss", owner_id=paul.key, legs=2)
self.assertTrue("dogs" not in cat2.__class__.fields.items())
self.db.put(cat2)
revivedcat1 = Cat.get(self.db, key)
self.assertTrue(revivedcat1 is not None)
self.db.delete(paul)
revivedcat2 = self.db.get(key)
self.assertTrue(revivedcat2 is None)
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_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_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_update_cat(self):
cat = Cat(name="whiskers")
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_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_delete_cat(self):
cat = Cat(name="whiskers")
cat.save(self.db)
key = cat.key
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
cat.delete(self.db)
revivedcat = self.db.get(key)
self.assertEqual(revivedcat, None)
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_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_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 = Cat.get(self.db, 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()
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_query_view(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 = Cat.all_with_n_legs(self.db, 3)
self.assertEqual(len(three_legged_cats), 1)
self.assertEqual(three_legged_cats[0].key, cat2.key)
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_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_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_update_cat(self):
cat = Cat(name="whiskers")
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_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_delete_cat(self):
cat = Cat(name="whiskers")
cat.save(self.db)
key = cat.key
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
cat.delete(self.db)
revivedcat = self.db.get(key)
self.assertEqual(revivedcat, None)
def test_included_refs_from_in_validator(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)
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_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, 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_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_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_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_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_get_cat(self):
cat = Cat(name="whiskers")
cat.save(self.db)
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
class CouchbaseModelTests(object):
def setUp(self):
mapper = ClassMapper([Dog, Cat, Person, JackRussell])
self.db = CouchbaseWrapper(mapper, COUCHBASE_HOST, COUCHBASE_BUCKET, read_only=False)
self.db.update_designs()
def tearDown(self):
pass
# Test the app
def test_app(self):
self.assertNotEqual(self.db, None)
def test_make_an_object(self):
dog = Dog(name="woofer")
self.assertEqual(dog.namespace, NAMESPACE)
self.assertEqual(dog.type, "dog")
self.assertEqual(dog.name, "woofer")
self.assertEqual(dog.__class__, Dog)
def test_make_an_object2(self):
dog = Dog(name="woofer")
self.assertEqual(dog.talk(), "woof")
def test_make_an_sub_object(self):
jack = JackRussell()
self.assertEqual(jack.talk(), "Yap")
jack.name = "jack"
jack.age = 12
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_cas(self):
cat = Cat(name="whiskers")
cat.save(self.db)
self.assertEqual(cat.namespace, NAMESPACE)
self.assertEqual(cat.type, "cat")
self.assertNotEqual(cat.cas, None)
def test_get_cat(self):
cat = Cat(name="whiskers")
cat.save(self.db)
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
def test_ref_to(self):
paul = Person(name="paul")
paul.save(self.db)
cat = Cat(name="whiskers", owner_id=paul.key)
cat.save(self.db)
self.assertEqual(cat.owner, paul)
self.assertEqual(cat.owner.name, "paul")
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_delete_cat(self):
cat = Cat(name="whiskers")
cat.save(self.db)
key = cat.key
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
cat.delete(self.db)
revivedcat = self.db.get(key)
self.assertEqual(revivedcat, 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.assertNotEqual(dog2.owner, None)
key = paul.key
dog.delete(self.db)
revivedpaul = self.db.get(key)
self.assertEqual(revivedpaul, None)
refresheddog2 = Dog.get(self.db, dog2.key)
self.assertEqual(refresheddog2.owner, None)
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.assertNotEqual(reviveddog1, None)
paul.delete(self.db)
reviveddog2 = self.db.get(key)
self.assertNotEqual(reviveddog2, None)
def test_update_cat(self):
cat = Cat(name="whiskers")
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 setcatfood(self):
self.cat.food = "biscuits"
def test_update_catfood(self):
self.cat = Cat(name="whiskers")
self.cat.save(self.db)
self.assertRaises(Exception, self.setcatfood)
def test_update_dogfood(self):
dog = Dog(name="fly")
dog.food = "biscuits"
dog.save(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_get_cat(self):
cat = Cat(name="whiskers")
cat.save(self.db)
another = Cat.get(self.db, cat.key)
self.assertEqual(cat, another)
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)
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)
def test_make_an_object_saved_cas(self):
cat = Cat(name="whiskers")
cat.save(self.db)
self.assertEqual(cat.namespace, NAMESPACE)
self.assertEqual(cat.type, "cat")
self.assertNotEqual(cat.cas, None)
def test_update_catfood(self):
self.cat = Cat(name="whiskers")
self.cat.save(self.db)
self.assertRaises(Exception, self.setcatfood)
