def test_hard_deleted_model_propagates_to_store_record(self):
"""
It could be the case that we have two store records, one that is hard deleted and the other that has a fk pointing to the hard deleted record.
When we deserialize, we want to ensure that the record with the fk pointer also gets the hard deleted flag set, while also not
deserializing the data into a model.
"""
# user will be deleted
user = MyUser(username='******')
user.save(update_dirty_bit_to=False)
# log may be synced in from other device
log = SummaryLog(user_id=user.id)
log.id = log.calculate_uuid()
StoreModelFacilityFactory(model_name="user",
id=user.id,
serialized=json.dumps(user.serialize()),
deleted=True,
hard_deleted=True)
StoreModelFacilityFactory(model_name="contentsummarylog",
id=log.id,
serialized=json.dumps(log.serialize()))
# make sure delete propagates to store due to deleted foreign key
self.mc.deserialize_from_store()
# have to serialize to update deleted models
self.mc.serialize_into_store()
self.assertFalse(SummaryLog.objects.filter(id=log.id).exists())
self.assertTrue(Store.objects.get(id=log.id).hard_deleted)
def test_store_hard_delete_propagates(self):
user = MyUser(username='******')
user.save(update_dirty_bit_to=False)
log = SummaryLog(user=user)
log.save(update_dirty_bit_to=False)
StoreModelFacilityFactory(model_name="user",
id=user.id,
serialized=json.dumps(user.serialize()),
hard_deleted=True,
deleted=True)
# make sure hard_deleted propagates to related models even if they are not hard_deleted
self.mc.deserialize_from_store()
self.assertTrue(HardDeletedModels.objects.filter(id=log.id).exists())
def test_in_app_hard_delete_propagates(self):
user = MyUser.objects.create(username='******')
log_id = uuid.uuid4().hex
log = SummaryLog(user=user, id=log_id)
StoreModelFacilityFactory(model_name="user",
id=user.id,
serialized=json.dumps(user.serialize()))
store_log = StoreModelFacilityFactory(model_name="contentsummarylog",
id=log.id,
serialized=json.dumps(
log.serialize()))
user.delete(hard_delete=True)
# preps log to be hard_deleted
self.mc.deserialize_from_store()
# updates store log to be hard_deleted
self.mc.serialize_into_store()
store_log.refresh_from_db()
self.assertTrue(store_log.hard_deleted)
self.assertEqual(store_log.serialized, '{}')
def build_buffer_items(self, transfer_session, **kwargs):
data = {
"profile":
kwargs.get("profile", 'facilitydata'),
"serialized":
kwargs.get("serialized", '{"test": 99}'),
"deleted":
kwargs.get("deleted", False),
"last_saved_instance":
kwargs.get("last_saved_instance",
uuid.uuid4().hex),
"last_saved_counter":
kwargs.get("last_saved_counter", 179),
"partition":
kwargs.get("partition", 'partition'),
"source_id":
kwargs.get("source_id",
uuid.uuid4().hex),
"model_name":
kwargs.get("model_name", "contentsummarylog"),
"conflicting_serialized_data":
kwargs.get("conflicting_serialized_data", ""),
"model_uuid":
kwargs.get("model_uuid", None),
"transfer_session":
transfer_session,
}
for i in range(self.chunk_size):
data['source_id'] = uuid.uuid4().hex
data["model_uuid"] = SummaryLog.compute_namespaced_id(
data["partition"], data["source_id"], data["model_name"])
Buffer.objects.create(**data)
buffered_items = Buffer.objects.filter(
transfer_session=self.syncclient.current_transfer_session)
serialized_records = BufferSerializer(buffered_items, many=True)
return json.dumps(serialized_records.data)