def test_view_json(self):
expected_count = Employee.objects.count()
form = QueryForm(self.request, {'view_json': [{'concept': 1}]})
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.record_count, expected_count)
def test_warn_on_bad_reverse_setting(self):
initial_warning_count = len(self.mock_handler.messages["warning"])
form = QueryForm(self.request, {"usernames_or_emails": ""})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 0)
self.assertEqual(len(self.mock_handler.messages["warning"]), initial_warning_count + 1)
def test_session(self):
form = QueryForm(self.request, {})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(form.instance.user, None)
self.assertEqual(form.instance.session_key,
self.request.session.session_key)
def test_clean_user_email_logging(self):
"""
We override the SERRANO_QUERY_REVERSE_NAME setting here to avoid the
setting not found warning in the forms code. This code counts the log
warnings so we need to avoid triggering unnecessary warnings.
"""
user = User.objects.create_user(username='******',
email='*****@*****.**')
user.save()
initial_warning_count = len(self.mock_handler.messages['warning'])
form = QueryForm(self.request, {'usernames_or_emails': ""})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 0)
self.assertEqual(len(self.mock_handler.messages['warning']),
initial_warning_count)
initial_warning_count = len(self.mock_handler.messages['warning'])
form = QueryForm(self.request, {'usernames_or_emails': 'user_1, \
[email protected], ~~invalid_username~~, ~~invalid@email~~'})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 2)
self.assertEqual(len(self.mock_handler.messages['warning']),
initial_warning_count + 2)
def test_both_json(self):
form = QueryForm(self.request, {
'context_json': {
'field': 'tests.title.salary', 'operator': 'gt',
'value': '1000'},
'view_json': [{'concept': 1}]})
self.assertTrue(form.is_valid())
def test_session(self):
form = QueryForm(self.request, {})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(form.instance.user, None)
self.assertEqual(form.instance.session_key,
self.request.session.session_key)
def test_view_json(self):
expected_count = Employee.objects.count()
form = QueryForm(self.request, {"view_json": [{"concept": 1}]})
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.record_count, expected_count)
def test_warn_on_bad_reverse_setting(self):
initial_warning_count = len(self.mock_handler.messages['warning'])
form = QueryForm(self.request, {'usernames_or_emails': ""})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 0)
self.assertEqual(len(self.mock_handler.messages['warning']),
initial_warning_count + 1)
def test_view_json(self):
form = QueryForm(self.request, {
'view_json': [{
'concept': self.c.pk
}],
})
self.assertTrue(form.is_valid())
def test_user(self):
user = User.objects.create_user(username='******', password='******')
self.request.user = user
form = QueryForm(self.request, {})
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.user, user)
self.assertEqual(instance.session_key, None)
def test_context_json(self):
expected_count = \
Employee.objects.filter(title__salary__gt=1000).count()
form = QueryForm(self.request, {'context_json': {
'field': 'tests.title.salary', 'operator': 'gt', 'value': '1000'}})
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.distinct_count, expected_count)
def test_force_count(self):
expected_count = Employee.objects.distinct().count()
form = QueryForm(self.request, {}, force_count=True)
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.distinct_count, expected_count)
self.assertEqual(instance.record_count, expected_count)
def test_force_count(self):
expected_count = Employee.objects.distinct().count()
form = QueryForm(self.request, {}, force_count=True)
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.distinct_count, expected_count)
self.assertEqual(instance.record_count, expected_count)
def test_context_json(self):
expected_count = Employee.objects.filter(title__salary__gt=1000).count()
form = QueryForm(
self.request, {"context_json": {"field": "tests.title.salary", "operator": "gt", "value": "1000"}}
)
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.distinct_count, expected_count)
def test_user(self):
user = User.objects.create_user(username='******', password='******')
self.request.user = user
form = QueryForm(self.request, {})
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.user, user)
self.assertEqual(instance.session_key, None)
def test_context_json(self):
form = QueryForm(
self.request, {
'context_json': {
'field': 'tests.title.salary',
'operator': 'gt',
'value': '1000'
}
})
self.assertTrue(form.is_valid())
def test_user(self):
user = User.objects.create_user(username="******", password="******")
self.request.user = user
form = QueryForm(self.request, {})
self.assertTrue(form.is_valid())
self.assertFalse(form.count_needs_update_context)
self.assertFalse(form.count_needs_update_view)
instance = form.save()
self.assertEqual(instance.user, user)
self.assertEqual(instance.session_key, None)
def test_both_json(self):
form = QueryForm(
self.request, {
'context_json': {
'field': 'tests.title.salary',
'operator': 'gt',
'value': '1000'
},
'view_json': [{
'concept': self.c.pk
}]
})
self.assertTrue(form.is_valid())
def test_with_user(self):
user = User.objects.create_user(username='******',
email='*****@*****.**')
user.save()
form = QueryForm(self.request, {'usernames_or_emails': 'user_1'})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
self.assertTrue(wait_mail_sent())
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ['*****@*****.**'])
def test_with_user(self):
user = User.objects.create_user(username='******',
email='*****@*****.**')
user.save()
form = QueryForm(self.request, {'usernames_or_emails': 'user_1'})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
self.assertTrue(wait_mail_sent())
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ['*****@*****.**'])
def post(self, request):
form = QueryForm(request, request.data)
if form.is_valid():
instance = form.save()
usage.log('create', instance=instance, request=request)
response = self.render(request, self.prepare(request, instance),
status=codes.created)
else:
data = {
'message': 'Error creating query',
'errors': dict(form.errors),
}
response = self.render(request, data,
status=codes.unprocessable_entity)
return response
def put(self, request, **kwargs):
instance = self.get_object(request, **kwargs)
form = QueryForm(request, request.data, instance=instance)
if form.is_valid():
instance = form.save()
usage.log('update', instance=instance, request=request)
response = self.render(request, self.prepare(request, instance))
else:
data = {
'message': 'Cannot update query',
'errors': dict(form.errors),
}
response = self.render(request, data,
status=codes.unprocessable_entity)
return response
def test_with_user(self):
user = User.objects.create_user(username="******", email="*****@*****.**")
user.save()
form = QueryForm(self.request, {"usernames_or_emails": "user_1"})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
time.sleep(5)
# Make sure the email was sent
self.assertEqual(len(mail.outbox), 1)
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ["*****@*****.**"])
def post(self, request):
form = QueryForm(request, request.data)
if form.is_valid():
instance = form.save()
usage.log('create', instance=instance, request=request)
response = self.render(request,
self.prepare(request, instance),
status=codes.created)
else:
data = {
'message': 'Error creating query',
'errors': dict(form.errors),
}
response = self.render(request,
data,
status=codes.unprocessable_entity)
return response
def put(self, request, **kwargs):
instance = self.get_object(request, **kwargs)
form = QueryForm(request, request.data, instance=instance)
if form.is_valid():
instance = form.save()
usage.log('update', instance=instance, request=request)
response = self.render(request, self.prepare(request, instance))
else:
data = {
'message': 'Cannot update query',
'errors': dict(form.errors),
}
response = self.render(request,
data,
status=codes.unprocessable_entity)
return response
def test_no_commit(self):
previous_user_count = User.objects.count()
form = QueryForm(self.request, {"usernames_or_emails": "*****@*****.**"})
instance = form.save(commit=False)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
time.sleep(5)
# The instance should not be saved and shared_users should be
# inaccessible on the model instance because the commit flag was False.
self.assertIsNone(instance.pk)
self.assertRaises(ValueError, lambda: instance.shared_users)
# Make sure no users were created and no email was sent
self.assertEqual(previous_user_count, User.objects.count())
self.assertEqual(len(mail.outbox), 0)
def test_with_mixed(self):
user = User.objects.create_user(username="******", email="*****@*****.**")
user.save()
previous_user_count = User.objects.count()
form = QueryForm(
self.request,
{
"usernames_or_emails": "user_1, \
[email protected], invalid+=email@fake@domain@com, "
},
)
instance = form.save()
self.assertEqual(instance.shared_users.count(), 2)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
time.sleep(5)
# Make sure the user was created
self.assertEqual(previous_user_count + 1, User.objects.count())
# Make sure the mail was sent
self.assertEqual(len(mail.outbox), 1)
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ["*****@*****.**", "*****@*****.**"])
# Remove a user from the list
previous_user_count = User.objects.count()
form = QueryForm(self.request, {"usernames_or_emails": "user_1"}, instance=instance)
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
time.sleep(5)
# Make sure the user count is unaffected
self.assertEqual(previous_user_count, User.objects.count())
# Make sure no email was generated as a result
self.assertEqual(len(mail.outbox), 1)
def test_with_email(self):
previous_user_count = User.objects.count()
form = QueryForm(self.request, {
'usernames_or_emails': '*****@*****.**',
})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
self.assertTrue(wait_mail_sent())
# Make sure the user was created
self.assertEqual(previous_user_count + 1, User.objects.count())
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ['*****@*****.**'])
def test_no_commit(self):
previous_user_count = User.objects.count()
form = QueryForm(self.request,
{'usernames_or_emails': '*****@*****.**'})
instance = form.save(commit=False)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
time.sleep(1)
# The instance should not be saved and shared_users should be
# inaccessible on the model instance because the commit flag was False.
self.assertIsNone(instance.pk)
self.assertRaises(ValueError, lambda: instance.shared_users)
# Make sure no users were created and no email was sent
self.assertEqual(previous_user_count, User.objects.count())
self.assertEqual(len(mail.outbox), 0)
def test_with_email(self):
previous_user_count = User.objects.count()
form = QueryForm(self.request, {
'usernames_or_emails': '*****@*****.**',
})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
self.assertTrue(wait_mail_sent())
# Make sure the user was created
self.assertEqual(previous_user_count + 1, User.objects.count())
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ['*****@*****.**'])
def test_with_email(self):
previous_user_count = User.objects.count()
previous_mail_count = len(mail.outbox)
form = QueryForm(self.request, {"usernames_or_emails": "*****@*****.**"})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
time.sleep(5)
# Make sure the user was created
self.assertEqual(previous_user_count + 1, User.objects.count())
# Make sure the mail was sent
self.assertEqual(previous_mail_count + 1, len(mail.outbox))
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ["*****@*****.**"])
def test_message(self):
user = User.objects.create_user(username='******',
email='*****@*****.**')
user.save()
message = u'ĘƞĵôƔ ťƕîš ǫųęŕƳ'
form = QueryForm(self.request, {'usernames_or_emails': 'user_1',
'message': message})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
self.assertTrue(wait_mail_sent())
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ['*****@*****.**'])
# Make sure the custom message is included in the body
self.assertRegexpMatches(mail.outbox[0].body, message)
def test_clean_user_email_logging(self):
"""
We override the SERRANO_QUERY_REVERSE_NAME setting here to avoid the
setting not found warning in the forms code. This code counts the log
warnings so we need to avoid triggering unnecessary warnings.
"""
user = User.objects.create_user(username='******',
email='*****@*****.**')
user.save()
initial_warning_count = len(self.mock_handler.messages['warning'])
form = QueryForm(self.request, {'usernames_or_emails': ""})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 0)
self.assertEqual(len(self.mock_handler.messages['warning']),
initial_warning_count)
initial_warning_count = len(self.mock_handler.messages['warning'])
form = QueryForm(
self.request, {
'usernames_or_emails':
'user_1, \
[email protected], ~~invalid_username~~, ~~invalid@email~~'
})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 2)
self.assertEqual(len(self.mock_handler.messages['warning']),
initial_warning_count + 2)
def test_message(self):
user = User.objects.create_user(username='******',
email='*****@*****.**')
user.save()
message = u'ĘƞĵôƔ ťƕîš ǫųęŕƳ'
form = QueryForm(self.request, {
'usernames_or_emails': 'user_1',
'message': message
})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
self.assertTrue(wait_mail_sent())
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to, ['*****@*****.**'])
# Make sure the custom message is included in the body
self.assertRegexpMatches(mail.outbox[0].body, message)
def test_with_mixed(self):
user = User.objects.create_user(username='******',
email='*****@*****.**')
user.save()
previous_user_count = User.objects.count()
form = QueryForm(
self.request, {
'usernames_or_emails':
'user_1, \
[email protected], invalid+=email@fake@domain@com, '
})
instance = form.save()
self.assertEqual(instance.shared_users.count(), 2)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
self.assertTrue(wait_mail_sent())
# Make sure the user was created
self.assertEqual(previous_user_count + 1, User.objects.count())
# Make sure the recipient list is correct
self.assertSequenceEqual(mail.outbox[0].to,
['*****@*****.**', '*****@*****.**'])
# Remove a user from the list
previous_user_count = User.objects.count()
form = QueryForm(self.request, {'usernames_or_emails': 'user_1'},
instance=instance)
instance = form.save()
self.assertEqual(instance.shared_users.count(), 1)
# Since save sends email asynchronously, wait for a while for the mail
# to go through.
time.sleep(1)
# Make sure the user count is unaffected
self.assertEqual(previous_user_count, User.objects.count())
# Make sure no email was generated as a result
self.assertEqual(len(mail.outbox), 1)
def test_view_json(self):
form = QueryForm(self.request, {'view_json': [{'concept': 1}]})
self.assertTrue(form.is_valid())
