def test_pre_delete_async(self, settings, save_model_action, extract_content_data, cache, extract_process_data):
settings.RUN_ASYNC = True
model = TestModel(
string_field='Test',
integer_field=1,
float_field=1.0,
)
old_object = serialize_model_instance(model)
model.string_field = None
model.integer_field = None
model.float_field = None
model.id = None
new_object = serialize_model_instance(model)
content = signals._extract_content_data(old_object, new_object)
extract_content_data.return_value = content
signals._pre_delete(model, instance=model)
# Check that extract process and access was done successfully
self.assertEqual(cache.get_last_access.call_count, 1)
self.assertEqual(cache.get_process.call_count, 1)
self.assertEqual(extract_process_data.call_count, 1)
# Check that was called asynchronously
self.assertEqual(save_model_action.call_count, 0)
self.assertEqual(save_model_action.apply_async.call_count, 1)
def test_post_save_async(self, settings, save_model_action, extract_content_data, cache, extract_process_data):
settings.RUN_ASYNC = True
model = TestModel(
string_field='Test',
integer_field=1,
float_field=1.0,
)
old_object = serialize_model_instance(model)
with patch.dict('audit_tools.audit.signals._CACHE', {id(model): old_object}):
model.string_field = 'Modified'
model.integer_field = 2
model.float_field = 2.0
new_object = serialize_model_instance(model)
content = signals._extract_content_data(old_object, new_object)
extract_content_data.return_value = content
signals._post_save(model, instance=model)
# Check that extract process and access was done successfully
self.assertEqual(cache.get_last_access.call_count, 1)
self.assertEqual(cache.get_process.call_count, 1)
self.assertEqual(extract_process_data.call_count, 1)
# Check that was called asynchronously
self.assertEqual(save_model_action.call_count, 0)
self.assertEqual(save_model_action.apply_async.call_count, 1)
def test_post_save_fail_save_model_action(self, settings, save_model_action, extract_content_data, cache,
extract_process_data, logger):
settings.RUN_ASYNC = False
save_model_action.side_effect = Exception
model = TestModel(
string_field='Test',
integer_field=1,
float_field=1.0,
)
old_object = serialize_model_instance(model)
model.string_field = 'Modified'
model.integer_field = 2
model.float_field = 2.0
new_object = serialize_model_instance(model)
content = signals._extract_content_data(old_object, new_object)
extract_content_data.return_value = content
signals._post_save(model, instance=model)
# Check that extract process and access was done successfully
self.assertEqual(cache.get_last_access.call_count, 1)
self.assertEqual(cache.get_process.call_count, 1)
self.assertEqual(extract_process_data.call_count, 1)
# Check that save process wasn't done successfully
self.assertEqual(logger.exception.call_count, 1)
def _post_save(sender, **kwargs):
try:
from audit_tools.audit.models import ACTIONS
from audit_tools.audit.tasks import save_model_action
i = kwargs['instance']
# Model
model = _extract_model_data(i)
# Old and new content
old_data = {}
if id(i) in _CACHE:
old_data = _CACHE[id(i)]
del _CACHE[id(i)]
new_data = serialize_model_instance(i)
content = _extract_content_data(old_data, new_data)
# Action
if not old_data and new_data:
action = ACTIONS.CREATE
else:
action = ACTIONS.UPDATE
# Instance
instance = _extract_instance_data(i)
# Timestamp
timestamp = datetime.datetime.now()
model_action = {
'model': model,
'action': action,
'content': content,
'instance': instance,
'timestamp': timestamp,
}
# Process
process = extract_process_data()
try:
# Get process
process = cache.get_process(process)
access = cache.get_last_access()
if not settings.RUN_ASYNC:
save_model_action(model_action, access, process)
else:
save_model_action.apply_async((model_action, access, process))
logger.info("<%s> Model:%s ID:%s", action.capitalize(),
model['full_name'], instance['id'])
except Exception:
logger.exception("<%s> Model:%s ID:%s", action.capitalize(),
model['full_name'], instance['id'])
except Exception:
logger.exception("<Post Save>")
def test_content_update(self):
model = TestModel(
string_field='Test',
integer_field=1,
float_field=1.0,
)
old_object = serialize_model_instance(model)
model.string_field = 'Modified'
new_object = serialize_model_instance(model)
keys = ['id', 'string_field', 'integer_field', 'float_field']
content = signals._extract_content_data(old_object, new_object)
self.assertItemsEqual(content['new'].keys(), keys)
self.assertItemsEqual(content['old'].keys(), keys)
self.assertEqual(content['new']['string_field'], 'Modified')
self.assertEqual(content['old']['string_field'], 'Test')
self.assertItemsEqual(content['changes'].keys(), ['string_field'])
def _post_save(sender, **kwargs):
try:
from audit_tools.audit.models import ACTIONS
from audit_tools.audit.tasks import save_model_action
i = kwargs["instance"]
# Model
model = _extract_model_data(i)
# Old and new content
old_data = {}
if id(i) in _CACHE:
old_data = _CACHE[id(i)]
del _CACHE[id(i)]
new_data = serialize_model_instance(i)
content = _extract_content_data(old_data, new_data)
# Action
if not old_data and new_data:
action = ACTIONS.CREATE
else:
action = ACTIONS.UPDATE
# Instance
instance = _extract_instance_data(i)
# Timestamp
timestamp = datetime.datetime.now()
model_action = {
"model": model,
"action": action,
"content": content,
"instance": instance,
"timestamp": timestamp,
}
# Process
process = extract_process_data()
try:
# Get process
process = cache.get_process(process)
access = cache.get_last_access()
if not settings.RUN_ASYNC:
save_model_action(model_action, access, process)
else:
save_model_action.apply_async((model_action, access, process))
logger.info("<%s> Model:%s ID:%s", action.capitalize(), model["full_name"], instance["id"])
except Exception:
logger.exception("<%s> Model:%s ID:%s", action.capitalize(), model["full_name"], instance["id"])
except Exception:
logger.exception("<Post Save>")
def _pre_save(sender, **kwargs):
try:
i = kwargs['instance']
if i.pk:
try:
original_instance = sender.objects.get(pk=i.pk)
_CACHE[id(i)] = serialize_model_instance(original_instance)
except:
# New object.
pass
except Exception:
logger.exception("<Pre Save>")
def _pre_save(sender, **kwargs):
try:
i = kwargs["instance"]
if i.pk:
try:
original_instance = sender.objects.get(pk=i.pk)
_CACHE[id(i)] = serialize_model_instance(original_instance)
except:
# New object.
pass
except Exception:
logger.exception("<Pre Save>")
def test_content_create(self):
model = TestModel()
model.string_field = 'Test'
model.integer_field = 1
model.float_field = 1.0
new_object = serialize_model_instance(model)
keys = ['id', 'string_field', 'integer_field', 'float_field']
content = signals._extract_content_data(None, new_object)
self.assertItemsEqual(content['new'].keys(), keys)
self.assertIsNone(content['old'])
self.assertEqual(content['new']['string_field'], 'Test')
self.assertEqual(content['new']['integer_field'], 1)
self.assertEqual(content['new']['float_field'], 1.0)
self.assertItemsEqual(content['changes'].keys(), keys)
def test_content_delete(self):
model = TestModel(
string_field='Test',
integer_field=1,
float_field=1.0,
)
old_object = serialize_model_instance(model)
model.string_field = None
model.integer_field = None
model.float_field = None
model.id = None
keys = ['id', 'string_field', 'integer_field', 'float_field']
content = signals._extract_content_data(old_object, None)
self.assertIsNone(content['new'])
self.assertItemsEqual(content['old'].keys(), keys)
self.assertEqual(content['old']['string_field'], 'Test')
self.assertEqual(content['old']['integer_field'], 1)
self.assertEqual(content['old']['float_field'], 1.0)
self.assertItemsEqual(content['changes'].keys(), keys)
def test_serialize_model_instance(self, model_to_dict):
model_to_dict.return_value = {
'date': datetime.date(2014, 12, 31),
'time': datetime.time(0, 0, 0),
'decimal': Decimal(1.0),
'str': b'str',
'unicode': 'unicode',
'file': FieldFile(instance=None, field=MagicMock(), name='foo')
}
expected_result = {
'date': datetime.datetime(2014, 12, 31),
'time': datetime.datetime(1, 1, 1, 0, 0, 0),
'decimal': 1.0,
'str': 'str',
'unicode': 'unicode',
'file': 'foo'
}
serialized_instance = utils.serialize_model_instance(None)
self.assertDictEqual(expected_result, serialized_instance)
