def test_edit_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {"domain": self.domain.domain, "enabled": False}
response = admin.domain_admin_edit(request, self.domain.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"],
urlresolvers.reverse("admin:domains:index"))
self.domain.refresh_from_db()
self.assertEqual(self.domain.enabled, False)
self.assertEqual(models.Domain.objects.count(), 1)
def test_cycle_session_less_than_week_left(self):
user = factories.UserFactory()
request = MockRequest(user)
request.session.save(must_create=True)
session_obj = request.session._get_session_from_db()
session_obj.expire_date = timezone.now() + timedelta(days=3)
session_obj.save()
session_key = request.session.session_key
self.middleware(request)
self.assertNotEqual(request.session.session_key, session_key)
user.refresh_from_db()
self.assertNotEqual(user.last_login, None)
def test_choose_type_get(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
page = models.HelpBasePage.objects.filter(parent__isnull=True).get()
response = views.choose_page_type(request, parent_pk=page.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context_data["parent_pk"], page.pk)
self.assertEqual(response.context_data["models"], [
models.HelpIndex._meta, models.AppPage._meta, models.HelpPage._meta
])
breadcrumbs = [p for p in response.context_data["breadcrumbs"]]
self.assertEqual(breadcrumbs, [page])
def setUp(self):
super().setUp()
self.user = factories.UserFactory()
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
self.sudo_protected_url = urls.reverse("user-delete")
self.sudo_url = urls.reverse("user-sudo")
def setUp(self):
self.user = factories.UserFactory()
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
self.url = urlresolvers.reverse("user-search", kwargs={"q": "cheddär"})
key = "%s-None-None-cheddär" % self.user.id
self.key = urllib.parse.quote(key)
if not login:
raise Exception("Could not log in")
def test_form_good_data(self):
params = {"username": self.user.username}
request = MockRequest(self.user)
form = DeleteAccountForm(request, data=params)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(request.user, AnonymousUser())
messages = list(request._messages)
self.assertEqual(str(messages[0]),
"Account deleted. Thanks for using our service.")
def test_suspended_user(self):
user = factories.UserFactory()
user.inboxenprofile.receiving_emails = False
user.inboxenprofile.save()
request = MockRequest(user)
request.path = "/blah/blah"
response = self.middleware(request)
self.assertNotEqual(response, {})
self.assertRedirects(response,
"{}?next={}".format(reverse("user-returned"),
"/blah/blah"),
fetch_redirect_response=False)
def test_index(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
QuestionFactory.create_batch(
len(models.Question.STATUS_CHOICES),
status=factory.Iterator(
[i[0] for i in models.Question.STATUS_CHOICES]))
response = views.question_admin_index(request)
self.assertEqual(response.status_code, 200)
expected_questions = models.Question.objects.all()
self.assertEqual(list(response.context_data["questions"]),
list(expected_questions))
def test_post_invalid(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {"succeeded": None}
request_obj = factories.RequestFactory(requester=self.user)
response = admin.request_admin_edit(request, request_obj.pk)
self.assertEqual(response.status_code, 200)
request_obj.refresh_from_db()
self.assertEqual(request_obj.succeeded, None)
self.assertEqual(request_obj.authorizer, None)
self.assertEqual(request_obj.date_decided, None)
def test_get(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request_obj = factories.RequestFactory()
response = admin.request_admin_edit(request, request_obj.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context_data["form"].instance, request_obj)
self.assertEqual(models.Request.objects.count(), 1)
with self.assertRaises(Http404):
admin.request_admin_edit(request, 0)
self.assertEqual(models.Request.objects.count(), 1)
def test_child_page(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
page = models.HelpBasePage.objects.filter(parent__isnull=False).get()
response = views.index(request, page_pk=page.pk)
self.assertEqual(response.status_code, 200)
expected_page = models.HelpBasePage.objects.filter(
parent__isnull=True).get()
self.assertEqual(response.context_data["page"], page)
breadcrumbs = [p for p in response.context_data["breadcrumbs"]]
self.assertEqual(breadcrumbs, [page.parent, page])
def setUp(self):
self.user = factories.UserFactory()
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
self.url = urls.reverse("user-home-search", kwargs={"q": "cheddär"})
self.key = create_search_cache_key(self.user.id, "cheddär", "home",
None, None)
if not login:
raise Exception("Could not log in")
def setUp(self):
super(HomeViewTestCase, self).setUp()
self.user = factories.UserFactory()
domain = factories.DomainFactory()
self.inboxes = factories.InboxFactory.create_batch(150,
domain=domain,
user=self.user)
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def test_index_page_logged_in(self):
user = factories.UserFactory()
assert self.client.login(username=user.username,
password="******",
request=MockRequest(user))
response = self.client.get(urlresolvers.reverse("index"))
self.assertEqual(response.status_code, 200)
self.assertNotIn("Join", str(response.content))
with override_settings(ENABLE_REGISTRATION=False):
response = self.client.get(urlresolvers.reverse("index"))
self.assertEqual(response.status_code, 200)
self.assertNotIn("Join", str(response.content))
def setUp(self):
self.user = factories.UserFactory()
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
assert login
self.inbox = factories.InboxFactory(user=self.user)
self.url = urls.reverse("inbox-disown",
kwargs={
"inbox": self.inbox.inbox,
"domain": self.inbox.domain.domain
})
def setUp(self):
"""Create the client and grab the user"""
self.user = factories.UserFactory()
other_user = factories.UserFactory(username="******")
for args in itertools.product([True, False],
[self.user, other_user, None]):
factories.DomainFactory(enabled=args[0], owner=args[1])
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def test_check_does_increase_count_if_full(self, now_mock):
now_mock.return_value = datetime.utcnow()
request = MockRequest()
request.META["REMOTE_ADDR"] = "127.0.0.1"
for i in range(self.limit_count):
self.limiter.counter_increase(request)
self.assertEqual(len(cache._cache), 1)
self.assertEqual(cache.get(self.make_key(request, now_mock())), self.limit_count)
self.limiter.counter_full(request)
self.assertEqual(len(cache._cache), 1)
self.assertEqual(cache.get(self.make_key(request, now_mock())), self.limit_count + 1)
def test_inbox_ratelimit_valid_keys(self):
request = MockRequest(self.user)
cache_prefix = u"hello€@.+-_ <>"
with override_settings(INBOX_LIMIT_CACHE_PREFIX=cache_prefix), \
warnings.catch_warnings(record=True) as w:
self.assertEqual(inbox_ratelimit.counter_full(request), False)
for i in range(settings.INBOX_LIMIT_COUNT + 1):
inbox_ratelimit.counter_increase(request)
self.assertEqual(inbox_ratelimit.counter_full(request), True)
self.assertEqual(len(w), 0)
def test_edit_post_invalid_owner(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {
"domain": self.domain.domain,
"enabled": False,
"owner": 0
}
response = admin.domain_admin_edit(request, self.domain.pk)
self.assertEqual(response.status_code, 200)
self.domain.refresh_from_db()
self.assertEqual(self.domain.enabled, True)
self.assertEqual(self.domain.owner, None)
self.assertEqual(models.Domain.objects.count(), 1)
def test_edit_post_blank(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
self.domain.owner = self.user
self.domain.save()
response = admin.domain_admin_edit(request, self.domain.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"],
urls.reverse("admin:domains:index"))
self.assertEqual(models.Domain.objects.count(), 1)
self.domain.refresh_from_db()
self.assertEqual(self.domain.owner, self.user)
def setUp(self):
super(QuestionDetailTestCase, self).setUp()
self.user = factories.UserFactory()
self.other_user = factories.UserFactory(username="******")
self.question = QuestionFactory(author=self.user,
status=models.Question.NEW)
self.page = AppPage.objects.get(app="tickets.urls")
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def test_urls_logged_in(self):
urls = [
reverse("user-registration"),
reverse("user-status"),
reverse("user-success"),
reverse("user-login")
]
assert self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
for url in urls:
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"], reverse("user-home"))
def test_has_no_preview(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
base_page = models.HelpBasePage.objects.filter(
parent__isnull=False).get()
ct = ContentType.objects.get(model="helppage", app_label="cms")
page = models.HelpPage.objects.create(parent=base_page,
title="FAQ",
body="",
content_type=ct)
response = views.edit_page(request, page_pk=page.pk)
self.assertEqual(response.status_code, 200)
response.render()
self.assertInHTML("<div class=\"panel-heading\">Preview</div>",
response.content.decode(),
count=0)
def setUp(self):
self.user = factories.UserFactory()
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
self.key = create_search_cache_key(self.user.id, "cheddår",
"inboxen.Inbox", None, None)
self.url = "%s?token=%s" % (
urls.reverse("search:api"),
self.key,
)
if not login:
raise Exception("Could not log in")
def setUp(self):
super(QuestionListTestCase, self).setUp()
self.user = factories.UserFactory()
QuestionFactory.create_batch(75,
author=self.user,
status=models.Question.NEW)
self.page = AppPage.objects.get(app="tickets.urls")
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def test_create_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {"domain": "example.com"}
self.assertEqual(models.Domain.objects.count(), 0)
response = admin.domain_admin_create(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"],
urlresolvers.reverse("admin:domains:index"))
domain = models.Domain.objects.get()
self.assertEqual(domain.owner, None)
self.assertEqual(domain.enabled, True)
self.assertEqual(domain.domain, "example.com")
def test_get_set(self):
user = factories.UserFactory()
request = MockRequest(user)
# check that there is not a custom expiry set
self.assertNotIn('_session_expiry', request.session)
self.middleware.process_request(request)
self.assertTrue(request.session.modified)
self.assertIn('_session_expiry', request.session)
# custom expiry has been set, this time the session should not be
# modified
request.session.modified = False
self.middleware.process_request(request)
self.assertFalse(request.session.modified)
self.assertIn('_session_expiry', request.session)
def test_route(self):
root_page = models.HelpBasePage.objects.get(parent__isnull=True)
child_page = models.HelpBasePage.objects.get(parent__isnull=False)
request = MockRequest()
self.assertEqual(root_page.route(request, []), (root_page, [], {}))
with self.assertRaises(Http404):
root_page.route(request, ["notapage"])
root_page.live = False
root_page.save()
with self.assertRaises(Http404):
root_page.route(request, [])
self.assertEqual(root_page.route(request, [child_page.slug]), (child_page.specific, (), {}))
self.assertEqual(child_page.route(request, []), (child_page, [], {}))
def test_check_does_increase_count_if_full(self, now_mock):
now_mock.return_value = datetime.utcnow()
cache.cache.clear()
request = MockRequest()
request.META["REMOTE_ADDR"] = "127.0.0.1"
for i in range(settings.REGISTER_LIMIT_COUNT):
utils.register_counter_increase(request)
self.assertEqual(len(cache.cache._cache), 1)
self.assertEqual(cache.cache.get(utils.make_key(request, now_mock())),
settings.REGISTER_LIMIT_COUNT)
utils.register_counter_full(request)
self.assertEqual(len(cache.cache._cache), 1)
self.assertEqual(cache.cache.get(utils.make_key(request, now_mock())),
settings.REGISTER_LIMIT_COUNT + 1)
def test_edit_page_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {"title": "Test Page", "slug": "test-page"}
page = models.HelpBasePage.objects.filter(parent__isnull=False).get()
response = views.edit_page(request, page_pk=page.pk)
self.assertEqual(response.status_code, 200)
request.POST["app"] = "tickets.urls"
response = views.edit_page(request, page_pk=page.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"],
reverse("admin:index", kwargs={"page_pk": page.pk}))
page.refresh_from_db()
self.assertEqual(page.title, "Test Page")
self.assertEqual(page.slug, "test-page")
