def test_store(self):
self.request._messages = default_storage(self.request)
self.request._messages.level = DEBUG
add_message(self.request, STORED_ERROR, "an SOS to the world ☢")
add_message(self.request, DEBUG, "this won't be persisted ☢")
self.assertEqual(len(get_messages(self.request)), 2)
self.assertEqual(len(self.backend.archive_list(self.user)), 1)
def fake_request(path='/', method='GET', user=None, extra={}):
params = {
'REQUEST_METHOD': method,
'PATH_INFO': path,
'wsgi.input': StringIO()
}
params.update(extra)
req = WSGIRequest(params)
req.user = user or AnonymousUser()
req.user.id = ''
req.user.username = '******'
req.user.first_name = 'mock_user'
req.user.is_superuser = True
req.user.groups.all = lambda: [GroupFactory(id=1)]
req.build_absolute_uri = lambda x=None: '/'
# for sessions middleware
req.session = build_fake_session()
# for messages middleware
req._messages = default_storage(req)
req.get_host = lambda x=None: 'localhost'
return req
def assertMessageCount(self, **kwargs):
"""
Asserts that the specified number of messages have been attached
for various message types. Usage would look like
``self.assertMessageCount(success=1)``.
"""
temp_req = self.client.request(**{"wsgi.input": None})
temp_req.COOKIES = self.client.cookies
storage = default_storage(temp_req)
messages = []
# To gain early access to the messages we have to decode the
# cookie on the test client.
if "messages" in self.client.cookies:
messages = storage._decode(self.client.cookies["messages"].value)
# If we don't have messages and we don't expect messages, we're done.
if not any(kwargs.values()) and not messages:
return
# If we expected messages and have none, that's a problem.
if any(kwargs.values()) and not messages:
error_msg = "Messages were expected, but none were set."
assert 0 == sum(kwargs.values()), error_msg
# Otherwise, make sure we got the expected messages.
for msg_type, count in kwargs.items():
msgs = [m.message for m in messages if msg_type in m.tags]
assert len(msgs) == count, "%s messages not as expected: %s" % (msg_type.title(), ", ".join(msgs))
def test_mission_proba(self):
for i in range(5):
# Create enough data to allow learn model to exist
a = create_lead()
a.state="WON"
a.save()
lead = Lead.objects.get(id=1)
lead.state="LOST" # Need more than one target class to build a solver
lead.save()
f = RequestFactory()
request = f.get("/")
request.user = User.objects.get(id=1)
request.session = {}
request._messages = default_storage(request)
lead = create_lead()
lead.state = "OFFER_SENT"
lead.save()
postSaveLead(request, lead, [], sync=True)
mission = lead.mission_set.all()[0]
if leads_learn.HAVE_SCIKIT:
self.assertEqual(mission.probability, lead.stateproba_set.get(state="WON").score)
else:
self.assertEqual(mission.probability, 50)
lead.state = "WON"
lead.save()
postSaveLead(request, lead, [], sync=True)
mission = Mission.objects.get(id=mission.id) # reload it
self.assertEqual(mission.probability, 100)
def check_attribute_change_action(self, klass, factory,
admin_action, attr, initial, final,
factory_extra=None):
if factory_extra is None:
d = {}
else:
d = factory_extra
d.update({attr: initial})
r0 = factory(**d)
r0.save()
r1 = factory(**d)
r1.save()
rs = klass.objects.filter(
id__in=[r0.id, r1.id])
req = self.factory.post('/', {})
req.user = self.user
req._messages = default_storage(req)
result = admin_action(req, rs)
self.assertIsNone(result)
rs = klass.objects.filter(id__in=[
r0.id, r1.id
])
for r in rs:
self.assertEqual(getattr(r, attr), final)
def test_tag_all(self):
req = self.factory.post('/', {})
req.user = self.user
factories.FoiRequestFactory(site=self.site)
factories.FoiRequestFactory(site=self.site)
frs = FoiRequest.objects.all()[:2]
result = self.request_admin.tag_all(req, frs)
self.assertEqual(result.status_code, 200)
self.assertEqual(frs[0].tags.count(), 0)
self.assertEqual(frs[1].tags.count(), 0)
req = self.factory.post('/', {'tags': 'one, two'})
req.user = self.user
req._messages = default_storage(req)
frs = FoiRequest.objects.filter(
id__in=[frs[0].id, frs[1].id])
result = self.request_admin.tag_all(req, frs)
self.assertIsNone(result)
frs = list(frs)
frs[0] = FoiRequest.objects.get(id=frs[0].id)
frs[1] = FoiRequest.objects.get(id=frs[1].id)
self.assertEqual(frs[0].tags.count(), 2)
self.assertEqual(frs[1].tags.count(), 2)
self.assertEqual(set([t.name for t in frs[0].tags.all()]), set(['one', 'two']))
def test_mark_same_as(self):
req = self.factory.post('/', {})
req.user = self.user
factories.FoiRequestFactory(site=self.site)
factories.FoiRequestFactory(site=self.site)
frs = FoiRequest.objects.all()[:2]
result = self.request_admin.mark_same_as(req, frs)
self.assertEqual(result.status_code, 200)
same_as = factories.FoiRequestFactory(site=self.site)
same_as.save()
req = self.factory.post('/', {'req_id': same_as.id})
req.user = self.user
req._messages = default_storage(req)
frs = FoiRequest.objects.filter(
id__in=[frs[0].id, frs[1].id])
result = self.request_admin.mark_same_as(req, frs)
self.assertIsNone(result)
same_as = FoiRequest.objects.get(id=same_as.id)
self.assertEqual(same_as.same_as_count, 2)
frs = list(frs)
frs[0] = FoiRequest.objects.get(id=frs[0].id)
frs[1] = FoiRequest.objects.get(id=frs[1].id)
self.assertEqual(frs[0].same_as, same_as)
self.assertEqual(frs[1].same_as, same_as)
def test_redeliver(self):
foireq = FoiRequest.objects.all()[0]
dm = factories.DeferredMessageFactory()
dm.save()
req = self.factory.post('/', {})
req.user = self.user
result = self.admin.redeliver(req,
DeferredMessage.objects.filter(
id__in=[dm.id]))
self.assertEqual(result.status_code, 200)
req = self.factory.post('/', {
'req_id': foireq.id
})
req.user = self.user
req._messages = default_storage(req)
result = self.admin.redeliver(req,
DeferredMessage.objects.filter(
id__in=[dm.id]))
self.assertIsNone(result)
dm = DeferredMessage.objects.get(id=dm.id)
self.assertEqual(dm.request, foireq)
def test_store(self):
self.request._messages = default_storage(self.request)
self.request._messages.level = DEBUG
add_message(self.request, STORED_ERROR, "an SOS to the world ☢")
add_message(self.request, DEBUG, "this won't be persisted ☢")
storage = get_messages(self.request)
self.assertEqual(len(storage), 2)
self.assertEqual(MessageArchive.objects.filter(user=self.user).count(), 1)
def get_request(self):
request = HttpRequest()
request.META['REMOTE_ADDR'] = '1.2.3.4'
request.method = 'POST'
request.session = SessionStore()
request._messages = default_storage(request)
request.user = AnonymousUser()
return request
def test_expire(self):
self.request._messages = default_storage(self.request)
add_message(self.request, STORED_ERROR, "an SOS to the world ☢")
ma = MessageArchive.objects.all()[0]
ma.message.date = now() - timedelta(days=365)
ma.message.save()
inbox = Inbox.objects.create(user=ma.user, message=ma.message)
self.assertTrue(inbox.expired())
def test_store_anonymous(self):
self.request.user = mock.MagicMock(wraps=self.user)
self.request.user.is_anonymous.return_value = True
self.request.user.is_authenticated.return_value = False
self.request._messages = default_storage(self.request)
add_message(self.request, STORED_ERROR, "an SOS to the world ☢")
add_message(self.request, ERROR, "this error won't be persisted ☢")
storage = get_messages(self.request)
self.assertEqual(len(storage), 2)
def test_update_message_mixin(self):
request = self.factory.post('/fake-path', {
'username': '******',
'email': '*****@*****.**',
})
request._messages = default_storage(request)
UpdateMessageView.as_view()(request)
self.assertEqual(len(get_messages(request)), 1)
def get_level(request):
"""
Returns the minimum level of messages to be recorded.
The default level is the ``MESSAGE_LEVEL`` setting. If this is not found,
the ``INFO`` level is used.
"""
storage = getattr(request, '_messages', default_storage(request))
return storage.level
def test_too_few_lead(self):
lead = create_lead()
f = RequestFactory()
request = f.get("/")
request.user = User.objects.get(id=1)
request.session = {}
request._messages = default_storage(request)
lead = create_lead()
postSaveLead(request, lead, [], sync=True) # Learn model cannot exist, but it should not raise error
def setUp(self):
assert settings.DEBUG == True
django.utils.translation.activate("en") # to test for error messages, just in case...
reset_zodb_structure()
create_game_instance(game_instance_id=TEST_GAME_INSTANCE_ID,
creator_login="******",
skip_randomizations=True) # handy to test stuffs
try:
test_http_host = "localhost:80"
self.client = Client()
self.factory = RequestMock(HTTP_HOST=test_http_host)
self.request = self.factory.get(HOME_URL)
assert self.request.user
assert self.request.datamanager.user.datamanager.request # double linking
assert self.request.session
assert self.request._messages is not None
assert self.request.datamanager
# we mimic messages middleware
from django.contrib.messages.storage import default_storage
self.request._messages = default_storage(self.request)
self.dm = self.request.datamanager
assert self.dm.is_initialized
assert self.dm.connection
self.dm.clear_all_event_stats()
self.dm.check_database_coherency() # important
assert self.dm.get_event_count("BASE_CHECK_DB_COHERENCY_PUBLIC_CALLED") == 1 # no bypassing because of wrong override
self.dm.set_game_state(True)
self.dm.set_activated_game_views(self.dm.get_activable_views().keys()) # QUICK ACCESS FIXTURE
self.dm.clear_all_event_stats()
#self.default_player = self.dm.get_character_usernames()[0]
#self._set_user(self.TEST_LOGIN)
self.initial_msg_sent_length = len(self.dm.get_all_dispatched_messages())
self.initial_msg_queue_length = len(self.dm.get_all_queued_messages())
# comment this to have eclipse's autocompletion to work for datamanager anyway
self.dm = AutoCheckingDM(self.dm) # protection against uncommitted, pending changes
# NO NEED TO COMMIT - transaction watcher should do it all #
except Exception, e:
print(">>>>>>>>>", repr(e))
self.tearDown(check=False) # cleanup of connection
raise
def test_create_network_alias_message(self):
url = reverse('horizon:project:networking:alias:networks:create')
response = self.client.post(url, self.form_data)
storage = default_storage(response.request)
message_cookie = response.cookies['messages'].value
messages = [m.message for m in storage._decode(message_cookie)]
msg = "Successfully created network alias: %s"
self.assertIn(msg % self.form_data['name'], messages)
self.assertMessageCount(success=1)
def _post_request(self, user):
data = {
'plugin_type': 'TextPlugin',
'placeholder': self._placeholder.pk,
'language': 'en',
}
request = self.get_post_request(data)
request.user = self.reload(user)
request._messages = default_storage(request)
return request
def _post_request(self, user):
data = {
'plugin_type': 'TextPlugin',
'placeholder': self._placeholder.pk,
'language': 'en',
}
request = self.get_post_request(data)
request.user = self.reload(user)
request._messages = default_storage(request)
return request
def test_unicode_dups():
"""Test that unicode values are preserved."""
request = HttpRequest()
setattr(request, '_messages', default_storage(request))
info(request, u'Titlé', u'Body')
info(request, u'Titlé', u'Body')
info(request, u'Another Titlé', u'Another Body')
storage = django_messages.get_messages(request)
assert len(storage) == 2, 'Too few or too many messages recorded.'
def test_l10n_dups():
"""Test that L10n values are preserved."""
request = HttpRequest()
setattr(request, "_messages", default_storage(request))
info(request, _("Title"), _("Body"))
info(request, _("Title"), _("Body"))
info(request, _("Another Title"), _("Another Body"))
storage = django_messages.get_messages(request)
eq_(len(storage), 2, "Too few or too many messages recorded.")
def test_unicode_dups():
"""Test that unicode values are preserved."""
request = HttpRequest()
setattr(request, "_messages", default_storage(request))
info(request, u"Titlé", u"Body")
info(request, u"Titlé", u"Body")
info(request, u"Another Titlé", u"Another Body")
storage = django_messages.get_messages(request)
eq_(len(storage), 2, "Too few or too many messages recorded.")
def test_no_dupes():
"""Test that duplicate messages aren't saved."""
request = HttpRequest()
setattr(request, "_messages", default_storage(request))
info(request, "Title", "Body")
info(request, "Title", "Body")
info(request, "Another Title", "Another Body")
storage = django_messages.get_messages(request)
eq_(len(storage), 2, "Too few or too many messages recorded.")
def test_no_dupes():
"""Test that duplicate messages aren't saved."""
request = HttpRequest()
setattr(request, '_messages', default_storage(request))
info(request, 'Title', 'Body')
info(request, 'Title', 'Body')
info(request, 'Another Title', 'Another Body')
storage = django_messages.get_messages(request)
assert len(storage) == 2, 'Too few or too many messages recorded.'
def test_l10n_dups():
"""Test that L10n values are preserved."""
request = HttpRequest()
setattr(request, '_messages', default_storage(request))
info(request, gettext('Title'), gettext('Body'))
info(request, gettext('Title'), gettext('Body'))
info(request, gettext('Another Title'), gettext('Another Body'))
storage = django_messages.get_messages(request)
assert len(storage) == 2, 'Too few or too many messages recorded.'
def test_unicode_dups():
"""Test that unicode values are preserved."""
request = HttpRequest()
setattr(request, '_messages', default_storage(request))
info(request, 'Titlé', 'Body')
info(request, 'Titlé', 'Body')
info(request, 'Another Titlé', 'Another Body')
storage = django_messages.get_messages(request)
assert len(storage) == 2, 'Too few or too many messages recorded.'
def test_l10n_dups():
"""Test that L10n values are preserved."""
request = HttpRequest()
setattr(request, '_messages', default_storage(request))
info(request, _('Title'), _('Body'))
info(request, _('Title'), _('Body'))
info(request, _('Another Title'), _('Another Body'))
storage = django_messages.get_messages(request)
assert len(storage) == 2, 'Too few or too many messages recorded.'
def test_no_dupes():
"""Test that duplicate messages aren't saved."""
request = HttpRequest()
setattr(request, '_messages', default_storage(request))
info(request, 'Title', 'Body')
info(request, 'Title', 'Body')
info(request, 'Another Title', 'Another Body')
storage = django_messages.get_messages(request)
assert len(storage) == 2, 'Too few or too many messages recorded.'
def request(self, *args, **kwargs):
user = kwargs.pop('user', self.user)
request = super(UserRequestFactory, self).request(*args, **kwargs)
request.user = user
request.session = import_string(settings.SESSION_ENGINE + '.SessionStore')()
request._messages = default_storage(request)
return request
def test_too_few_lead(self):
lead = create_lead()
f = RequestFactory()
request = f.get("/")
request.user = User.objects.get(id=1)
request.session = {}
request._messages = default_storage(request)
lead = create_lead()
postSaveLead(
request, lead, [], sync=True
) # Learn model cannot exist, but it should not raise error
def test_response_whitout_GET(self):
from django.contrib.messages.storage import default_storage
request = HttpRequest()
request.session = SessionStore('asd')
request._messages = default_storage(request)
response = easy.action_response(request)
self.assertEqual(len(request._messages._queued_messages), 0)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], '.')
def get_level(request):
"""
Returns the minimum level of messages to be recorded.
The default level is the ``MESSAGE_LEVEL`` setting. If this is not found,
the ``INFO`` level is used.
"""
if hasattr(request, "_messages"):
storage = request._messages
else:
storage = default_storage(request)
return storage.level
def test_response_whitout_GET(self):
from django.contrib.messages.storage import default_storage
request = HttpRequest()
request.session = SessionStore('asd')
request._messages = default_storage(request)
response = easy.action_response(request)
self.assertEqual(len(request._messages._queued_messages), 0)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], '.')
def test_remove_center_post_valid(self):
view = views.RemoveCenterView.as_view()
center = create_center('12345')
data = {'center_number': center.code}
request = self.factory.post('/', data)
request.user = self.user
request.session = {}
request._messages = default_storage(request)
response = view(request)
self.assertEqual(response.status_code, 302)
with self.assertRaises(Center.DoesNotExist):
Center.objects.get(code=center.code)
def test_remove_center_post_valid(self):
view = views.RemoveCenterView.as_view()
center = create_center('12345')
data = {'center_number': center.code}
request = self.factory.post('/', data)
request.user = self.user
request.session = {}
request._messages = default_storage(request)
response = view(request)
self.assertEqual(response.status_code, 302)
with self.assertRaises(Center.DoesNotExist):
Center.objects.get(code=center.code)
def request(self, *args, **kwargs):
user = kwargs.pop('user', self.user)
request = super(UserRequestFactory, self).request(*args, **kwargs)
request.user = user
request.session = import_string(settings.SESSION_ENGINE +
'.SessionStore')()
request._messages = default_storage(request)
return request
def test_too_greedy(session, api_rf, filled_cart):
product = filled_cart.items.all()[0].product
data = {'quantity': 10, 'product': product.id}
request = api_rf.put('/shop/api/cart', data)
request.customer = filled_cart.customer
request.session = session
request._messages = default_storage(request)
response = CartViewSet.as_view({'put': 'update'})(request, pk=product.id)
assert response.status_code == 200
filled_cart.refresh_from_db()
assert filled_cart.num_items == 1
assert filled_cart.items.all()[0].quantity == 5 # not 10, as requested
def get_level(request):
"""
Returns the minimum level of messages to be recorded.
The default level is the ``MESSAGE_LEVEL`` setting. If this is not found,
the ``INFO`` level is used.
"""
if hasattr(request, '_messages'):
storage = request._messages
else:
storage = default_storage(request)
return storage.level
def test_not_exist_view(self):
from django.contrib.messages.storage import default_storage
request = HttpRequest()
request.session = SessionStore('asd')
request._messages = default_storage(request)
response1 = self.admin.easy_list_view(request, 'not')
response2 = self.admin.easy_object_view(request, 1, 'not')
self.assertEqual(response1.status_code, 302)
self.assertEqual(response2.status_code, 302)
self.assertEqual(len(request._messages._queued_messages), 2)
def test_not_exist_view(self):
from django.contrib.messages.storage import default_storage
request = HttpRequest()
request.session = SessionStore('asd')
request._messages = default_storage(request)
response1 = self.admin.easy_list_view(request, 'not')
response2 = self.admin.easy_object_view(request, 1, 'not')
self.assertEqual(response1.status_code, 302)
self.assertEqual(response2.status_code, 302)
self.assertEqual(len(request._messages._queued_messages), 2)
def test_form_invalid_deve_adicionar_mensagem_de_erro(self):
request = RequestFactory().get(self.view_url)
request.user = self.usuario_homologador
request.session = {}
storage = default_storage(request)
request._messages = storage
view = views.UpdateAvaliacaoHomologadorInscricaoView()
view.setup(request, pk=self.avaliacao.id)
view.object = None
view.form_invalid(mock.Mock())
self.assertTrue(storage.added_new)
self.assertIn("Por favor, corrija os erros abaixo para continuar.",
[m.message for m in storage])
def test_response_normal(self):
from django.contrib.messages.storage import default_storage
request = HttpRequest()
request.GET = QueryDict('test=asd')
request.session = SessionStore('asd')
request._messages = default_storage(request)
response = easy.action_response(request, 'Some message')
self.assertEqual(len(request._messages._queued_messages), 1)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], './?test=asd')
def test_response_without_querystring(self):
from django.contrib.messages.storage import default_storage
request = HttpRequest()
request.GET = QueryDict('test=asd')
request.session = SessionStore('asd')
request._messages = default_storage(request)
response = easy.action_response(request, 'Some message', keep_querystring=False)
self.assertEqual(len(request._messages._queued_messages), 1)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], '.')
def test_form_valid_deve_adicionar_mensagem_de_sucesso(self, form_valid):
request = RequestFactory().get("/")
request.user = mock.Mock()
request.session = {}
view = views.GenericDeleteResultadoView()
view.setup(request, pk=self.resultado.id)
view.model = mock.Mock()
view.success_message = "Teste"
storage = default_storage(request)
request._messages = storage
view.form_valid(form=mock.MagicMock())
self.assertTrue(storage.added_new)
self.assertIn(view.success_message, [m.message for m in storage])
def test_form_valid_deve_adicionar_mensagem_de_sucesso(
self, form_valid, delay):
request = RequestFactory().get("/")
request.user = mock.Mock()
request.session = {}
view = views.ResultadoFileView()
view.setup(request, resultado_pk=self.resultado.id)
storage = default_storage(request)
request._messages = storage
view.form_valid(form=mock.MagicMock())
self.assertTrue(storage.added_new)
self.assertIn(
"Sua solicitação está sendo processada. Você receberá os arquivos por e-mail.",
[m.message for m in storage])
def test_form_valid_deve_adicionar_mensagem_de_sucesso(self, redistribuir):
INSCRICOES_A_REDISTRIBUIR = 1
redistribuir.return_value = INSCRICOES_A_REDISTRIBUIR
request = RequestFactory().get(self.view_url)
request.session = {}
view = views.RedistribuirInscricaoView()
view.setup(request, fase_pk=self.fase_analise.id)
storage = default_storage(request)
request._messages = storage
view.form_valid(RedistribuirForm(fase=self.fase_analise))
self.assertTrue(storage.added_new)
self.assertIn(
f"{INSCRICOES_A_REDISTRIBUIR} inscrições foram redistribuídas com sucesso",
[m.message for m in storage])
def test_remove_center_post_valid(self):
tally = create_tally()
tally.users.add(self.user)
center = create_center('12345', tally=tally)
view = views.RemoveCenterView.as_view()
data = {
'center_number': center.code,
'tally_id': tally.pk,
}
request = self.factory.post('/', data)
request.user = self.user
request.session = {}
request._messages = default_storage(request)
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
def test_form_valid_deve_adicionar_mensagem_de_sucesso(
self, new, gerar_resultado_preliminar, form_valid):
request = RequestFactory().get("/")
request.user = mock.Mock()
request.session = {}
view = views.ResultadoPreliminarView()
view.setup(request, fase_pk=self.fase_analise.id)
storage = default_storage(request)
request._messages = storage
view.form_valid(form=mock.Mock())
self.assertTrue(storage.added_new)
self.assertIn(
"Sua solicitação está sendo processada."
" Esta operação pode demorar alguns minutos.",
[m.message for m in storage])
def test_html_rendered_properly():
"""Html markup is properly displayed in final template."""
request = HttpRequest()
setattr(request, '_messages', default_storage(request))
# This will call _file_message, which in turn calls _make_message, which in
# turn renders the message_content.html template, which adds html markup.
# We want to make sure this markup reaches the final rendering unescaped.
info(request, 'Title', 'Body')
messages = django_messages.get_messages(request)
template = loader.get_template('messages.html')
html = template.render({'messages': messages})
assert '<h2>' in html # The html from _make_message is not escaped.
def get_level(request):
"""
<<<<<<< HEAD
Returns the minimum level of messages to be recorded.
The default level is the ``MESSAGE_LEVEL`` setting. If this is not found,
the ``INFO`` level is used.
=======
Return the minimum level of messages to be recorded.
The default level is the ``MESSAGE_LEVEL`` setting. If this is not found,
use the ``INFO`` level.
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
"""
storage = getattr(request, '_messages', default_storage(request))
return storage.level
def assertMessageCount(self, response=None, **kwargs):
"""Asserts that the expected number of messages have been attached.
The expected number of messages can be specified per message type.
Usage would look like ``self.assertMessageCount(success=1)``.
"""
temp_req = self.client.request(**{'wsgi.input': None})
temp_req.COOKIES = self.client.cookies
storage = default_storage(temp_req)
messages = []
if response is None:
# To gain early access to the messages we have to decode the
# cookie on the test client.
if 'messages' in self.client.cookies:
message_cookie = self.client.cookies['messages'].value
messages = storage._decode(message_cookie)
# Check for messages in the context
elif hasattr(response, "context") and "messages" in response.context:
messages = response.context["messages"]
# Check for messages attached to the request on a TemplateResponse
elif hasattr(response, "_request") and hasattr(response._request,
"_messages"):
messages = response._request._messages._queued_messages
# If we don't have messages and we don't expect messages, we're done.
if not any(kwargs.values()) and not messages:
return
# If we expected messages and have none, that's a problem.
if any(kwargs.values()) and not messages:
error_msg = "Messages were expected, but none were set."
assert 0 == sum(kwargs.values()), error_msg
# Otherwise, make sure we got the expected messages.
for msg_type, count in kwargs.items():
msgs = [
force_text(m.message) for m in messages if msg_type in m.tags
]
assert len(msgs) == count, \
"%s messages not as expected: %s" % (msg_type.title(),
", ".join(msgs))
def test_remove_station_post_valid(self):
center = create_center('12345')
station = create_station(center)
self.assertEqual(
Station.objects.get(center__code=center.code,
station_number=station.station_number),
station)
view = views.RemoveStationView.as_view()
data = {
'center_number': center.code,
'station_number': station.station_number
}
request = self.factory.post('/', data)
request.user = self.user
request.session = {}
request._messages = default_storage(request)
response = view(request)
self.assertEqual(response.status_code, 302)
with self.assertRaises(Station.DoesNotExist):
Station.objects.get(center__code=center.code,
station_number=station.station_number)
def test_redeliver(self):
foireq = FoiRequest.objects.all()[0]
dm = factories.DeferredMessageFactory()
dm.save()
req = self.factory.post('/', {})
req.user = self.user
result = self.admin.redeliver(
req, DeferredMessage.objects.filter(id__in=[dm.id]))
self.assertEqual(result.status_code, 200)
req = self.factory.post('/', {'req_id': foireq.id})
req.user = self.user
req._messages = default_storage(req)
result = self.admin.redeliver(
req, DeferredMessage.objects.filter(id__in=[dm.id]))
self.assertIsNone(result)
dm = DeferredMessage.objects.get(id=dm.id)
self.assertEqual(dm.request, foireq)
def get_messages(request):
"""
Return the message storage on the request if it exists, otherwise return
an empty list.
"""
return getattr(request, '_messages', [])
def get_level(request):
"""
Return the minimum level of messages to be recorded.
The default level is the ``MESSAGE_LEVEL`` setting. If this is not found,
use the ``INFO`` level.
"""
storage = getattr(request, '_messages', default_storage(request))
return storage.level
def set_level(request, level):
"""
Set the minimum level of messages to be recorded, and return ``True`` if
the level was recorded successfully.
If set to ``None``, use the default level (see the get_level() function).
"""
if not hasattr(request, '_messages'):
return False
request._messages.level = level
return True
def post(self, *args, **kwargs):
req = super().post(*args, **kwargs)
req.user = User()
req.session = SessionStore()
req._messages = default_storage(req)
return req
def test_add_empty(self):
self.request._messages = default_storage(self.request)
add_message(self.request, DEBUG, '')
self.assertEqual(len(get_messages(self.request)), 0)