class MiddlewareTest(TearDownMixin):
"""
Test the middleware responsible for connecting and disconnecting the signals used in automatic logging.
"""
def setUp(self):
self.middleware = AuditlogMiddleware()
self.factory = RequestFactory()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
def test_request_anonymous(self):
"""No actor will be logged when a user is not logged in."""
# Create a request
request = self.factory.get('/')
request.user = AnonymousUser()
# Run middleware
self.middleware.process_request(request)
# Validate result
from auditlog.middleware import threadlocal
# Validate result
self.assertEquals(threadlocal.auditlog['actor'], None)
def test_request(self):
"""The actor will be logged when a user is logged in."""
# Create a request
request = self.factory.get('/')
request.user = self.user
# Run middleware
self.middleware.process_request(request)
from auditlog.middleware import threadlocal
# Validate result
self.assertEquals(threadlocal.auditlog['actor'], request.user)
def send_credit_decision_inquiry(request):
"""
Send credit decision inquiry to credit decision service
"""
AuditlogMiddleware().process_request(request)
customer_id = request.data.get("customer_id")
business_id = request.data.get("business_id")
identity_number = request.data.get("identity_number")
if request.method == "POST" and (customer_id or business_id
or identity_number):
contact = None
if customer_id:
contact = Contact.objects.get(pk=customer_id)
if contact.business_id:
business_id = contact.business_id
elif contact.national_identification_number:
identity_number = contact.national_identification_number
else:
return Response(
{
"message":
_("Cannot find business id or national identification number in customer data."
)
},
status=status.HTTP_400_BAD_REQUEST,
)
json_data = None
json_error = None
if business_id:
business_id = business_id.replace("-", "")
json_data, json_error = _get_company_decision(
business_id, request.user, contact)
if identity_number:
json_data, json_error = _get_consumer_decision(
identity_number, request.user)
if json_error:
return _error_response(json_error)
if identity_number:
serializer_data = map_consumer_response(json_data, request)
serializer = CreditDecisionConsumerSerializer(serializer_data,
many=True)
return Response(serializer.data)
if customer_id or business_id:
credit_decision_queryset = CreditDecision.get_credit_decision_queryset_by_customer(
customer_id=customer_id, business_id=business_id)
credit_decision_serializer = CreditDecisionSerializer(
credit_decision_queryset, many=True)
return Response(credit_decision_serializer.data)
return Response(None, status=status.HTTP_400_BAD_REQUEST)
def setUp(self):
self.get_response_mock = mock.Mock()
self.response_mock = mock.Mock()
self.middleware = AuditlogMiddleware(
get_response=self.get_response_mock)
self.factory = RequestFactory()
self.user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
def setUp(self):
self.middleware = AuditlogMiddleware()
self.factory = RequestFactory()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
class MiddlewareTest(TestCase):
"""
Test the middleware responsible for connecting and disconnecting the signals used in automatic logging.
"""
def setUp(self):
self.middleware = AuditlogMiddleware()
self.factory = RequestFactory()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
def test_request_anonymous(self):
"""No actor will be logged when a user is not logged in."""
# Create a request
request = self.factory.get('/')
request.user = AnonymousUser()
# Run middleware
self.middleware.process_request(request)
# Validate result
self.assertFalse(pre_save.has_listeners(LogEntry))
# Finalize transaction
self.middleware.process_exception(request, None)
def test_request(self):
"""The actor will be logged when a user is logged in."""
# Create a request
request = self.factory.get('/')
request.user = self.user
# Run middleware
self.middleware.process_request(request)
# Validate result
self.assertTrue(pre_save.has_listeners(LogEntry))
# Finalize transaction
self.middleware.process_exception(request, None)
def test_response(self):
"""The signal will be disconnected when the request is processed."""
# Create a request
request = self.factory.get('/')
request.user = self.user
# Run middleware
self.middleware.process_request(request)
self.assertTrue(
pre_save.has_listeners(LogEntry)
) # The signal should be present before trying to disconnect it.
self.middleware.process_response(request, HttpResponse())
# Validate result
self.assertFalse(pre_save.has_listeners(LogEntry))
def test_exception(self):
"""The signal will be disconnected when an exception is raised."""
# Create a request
request = self.factory.get('/')
request.user = self.user
# Run middleware
self.middleware.process_request(request)
self.assertTrue(
pre_save.has_listeners(LogEntry)
) # The signal should be present before trying to disconnect it.
self.middleware.process_exception(request, ValidationError("Test"))
# Validate result
self.assertFalse(pre_save.has_listeners(LogEntry))
def setUp(self):
self.middleware = AuditlogMiddleware()
self.factory = RequestFactory()
self.user = User.objects.create_user(username='******', email='*****@*****.**', password='******')
class MiddlewareTest(TestCase):
"""
Test the middleware responsible for connecting and disconnecting the signals used in automatic logging.
"""
def setUp(self):
self.middleware = AuditlogMiddleware()
self.factory = RequestFactory()
self.user = User.objects.create_user(username='******', email='*****@*****.**', password='******')
def test_request_anonymous(self):
"""No actor will be logged when a user is not logged in."""
# Create a request
request = self.factory.get('/')
request.user = AnonymousUser()
# Run middleware
self.middleware.process_request(request)
# Validate result
self.assertFalse(pre_save.has_listeners(LogEntry))
# Finalize transaction
self.middleware.process_exception(request, None)
def test_request(self):
"""The actor will be logged when a user is logged in."""
# Create a request
request = self.factory.get('/')
request.user = self.user
# Run middleware
self.middleware.process_request(request)
# Validate result
self.assertTrue(pre_save.has_listeners(LogEntry))
# Finalize transaction
self.middleware.process_exception(request, None)
def test_response(self):
"""The signal will be disconnected when the request is processed."""
# Create a request
request = self.factory.get('/')
request.user = self.user
# Run middleware
self.middleware.process_request(request)
self.assertTrue(pre_save.has_listeners(LogEntry)) # The signal should be present before trying to disconnect it.
self.middleware.process_response(request, HttpResponse())
# Validate result
self.assertFalse(pre_save.has_listeners(LogEntry))
def test_exception(self):
"""The signal will be disconnected when an exception is raised."""
# Create a request
request = self.factory.get('/')
request.user = self.user
# Run middleware
self.middleware.process_request(request)
self.assertTrue(pre_save.has_listeners(LogEntry)) # The signal should be present before trying to disconnect it.
self.middleware.process_exception(request, ValidationError("Test"))
# Validate result
self.assertFalse(pre_save.has_listeners(LogEntry))
def initial(self, request, *args, **kwargs):
# We need to process logged in user again because Django Rest
# Framework handles authentication after the
# AuditLogMiddleware.
AuditlogMiddleware().process_request(request)
return super().initial(request, *args, **kwargs)
