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