def test_check_doesnt_increase_count_if_not_full(self, now_mock):
now_mock.return_value = datetime.utcnow()
request = MockRequest()
request.META["REMOTE_ADDR"] = "127.0.0.1"
self.limiter.counter_full(request)
self.assertEqual(len(cache._cache), 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_create_post_invalid(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
self.assertEqual(models.Domain.objects.count(), 0)
response = admin.domain_admin_create(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(models.Domain.objects.count(), 0)
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_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_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_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_create_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=True).get()
response = views.create_page(request, "helppage", page.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(models.HelpPage.objects.count(), 0)
request.POST["body"] = "body"
response = views.create_page(request, "helppage", page.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"], reverse("admin:index", kwargs={"page_pk": page.pk}))
new_page = models.HelpBasePage.objects.get(slug="test-page", parent_id=page.pk)
self.assertEqual(new_page.specific_class, models.HelpPage)
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")
def test_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
post = BlogPostFactory(author=self.user)
other_post = BlogPostFactory(author=self.user)
response = views.blog_admin_delete(request, post.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(models.BlogPost.objects.count(), 2)
request.POST = {"yes_delete": True}
response = views.blog_admin_delete(request, post.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"], urlresolvers.reverse("admin:blog:index"))
self.assertEqual(models.BlogPost.objects.count(), 1)
self.assertEqual(models.BlogPost.objects.get(), other_post)
def test_make_key_ipv4(self):
now = timezone.now()
now.replace(second=15)
request = MockRequest()
request.META["REMOTE_ADDR"] = "127.0.0.1"
key1 = utils.make_key(request, now)
# IPv4 addresses are one per host
request.META["REMOTE_ADDR"] = "127.0.0.2"
key2 = utils.make_key(request, now)
self.assertNotEqual(key1, key2)
# seconds don't matter
now.replace(second=45)
key3 = utils.make_key(request, now)
self.assertEqual(key2, key3)
def test_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
response = views.blog_admin_create(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(models.BlogPost.objects.count(), 0)
request.POST = {"subject": "Test", "body": "Hello"}
response = views.blog_admin_create(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"], urlresolvers.reverse("admin:blog:index"))
self.assertEqual(models.BlogPost.objects.count(), 1)
post = models.BlogPost.objects.get()
self.assertEqual(post.subject, "Test")
self.assertEqual(post.body, "Hello")
self.assertEqual(post.draft, True)
def test_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
post = BlogPostFactory(author=self.user, draft=True, subject="no", body="no")
response = views.blog_admin_edit(request, post.pk)
self.assertEqual(response.status_code, 200)
request.POST = {"subject": "Test", "body": "Hello"}
response = views.blog_admin_edit(request, post.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"], urlresolvers.reverse("admin:blog:index"))
self.assertEqual(models.BlogPost.objects.count(), 1)
post = models.BlogPost.objects.get()
self.assertEqual(post.subject, "Test")
self.assertEqual(post.body, "Hello")
self.assertEqual(post.draft, False)
def test_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
post = BlogPostFactory(author=self.user)
other_post = BlogPostFactory(author=self.user)
response = views.blog_admin_delete(request, post.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(models.BlogPost.objects.count(), 2)
request.POST = {"yes_delete": True}
response = views.blog_admin_delete(request, post.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"],
urls.reverse("admin:blog:index"))
self.assertEqual(models.BlogPost.objects.count(), 1)
self.assertEqual(models.BlogPost.objects.get(), other_post)
def test_route(self):
page = models.AppPage.objects.get()
request = MockRequest()
pg, args, kwargs = page.route(request, [])
self.assertEqual(pg, page)
self.assertEqual(args, ())
self.assertEqual(kwargs, {})
self.assertEqual(page._view.view_class, ticket_views.QuestionHomeView)
request.path = "/help/questions/ticket/12/"
pg, args, kwargs = page.route(request, ["ticket", "12"])
self.assertEqual(pg, page)
self.assertEqual(args, ())
self.assertEqual(kwargs, {"pk": "12"})
self.assertEqual(page._view.view_class, ticket_views.QuestionDetailView)
page.live = False
page.save()
with self.assertRaises(Http404):
page.route(request, ["ticket", "12"])
def test_post_succeeded(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {"succeeded": True}
request_obj = factories.RequestFactory(requester=self.user)
# also pre-create profile
pool_amount = request_obj.requester.inboxenprofile.pool_amount
response = admin.request_admin_edit(request, request_obj.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"],
urlresolvers.reverse("admin:requests:index"))
request_obj.refresh_from_db()
self.assertEqual(request_obj.succeeded, True)
self.assertEqual(request_obj.authorizer, self.user)
self.assertNotEqual(request_obj.date_decided, None)
request_obj.requester.inboxenprofile.refresh_from_db()
self.assertEqual(request_obj.requester.inboxenprofile.pool_amount,
pool_amount + request_obj.amount)
def test_index(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
BlogPostFactory.create_batch(2,
draft=factory.Iterator([True, False]),
author=self.user)
response = views.blog_admin_index(request)
self.assertEqual(response.status_code, 200)
expected_posts = models.BlogPost.objects.all()
self.assertEqual(list(response.context_data["posts"]),
list(expected_posts))
def test_delete_page_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
page = models.HelpBasePage.objects.filter(parent__isnull=False).get()
response = views.delete_page(request, page_pk=page.pk)
self.assertEqual(response.status_code, 200)
# page still exists
page.refresh_from_db()
request.POST["yes_delete"] = True
response = views.delete_page(request, page_pk=page.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"], reverse("admin:index", kwargs={"page_pk": page.parent_id}))
# page was deleted
with self.assertRaises(models.HelpBasePage.DoesNotExist):
page.refresh_from_db()
def test_404(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
page = models.HelpBasePage.objects.filter(parent__isnull=True).get()
with self.assertRaises(Http404):
views.create_page(request, "helppage", 123)
with self.assertRaises(Http404):
views.create_page(request, "notpage", page.pk)
with self.assertRaises(Http404):
views.create_page(request, "notpage", 123)
def test_get(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
question = QuestionFactory()
with self.assertRaises(Http404):
views.question_admin_response(request, 0)
response = views.question_admin_response(request, question.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context_data["question"], question)
self.assertEqual(response.context_data["form"].question, question)
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_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", response.content)
with override_settings(ENABLE_REGISTRATION=False):
response = self.client.get(urlresolvers.reverse("index"))
self.assertEqual(response.status_code, 200)
self.assertNotIn("Join", response.content)
def setUp(self):
"""Create the client and grab the user"""
super(InboxInlineEditTestCase, self).setUp()
self.user = factories.UserFactory()
self.inbox = factories.InboxFactory(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_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
response = views.blog_admin_create(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(models.BlogPost.objects.count(), 0)
request.POST = {"subject": "Test", "body": "Hello"}
response = views.blog_admin_create(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"],
urlresolvers.reverse("admin:blog:index"))
self.assertEqual(models.BlogPost.objects.count(), 1)
post = models.BlogPost.objects.get()
self.assertEqual(post.subject, "Test")
self.assertEqual(post.body, "Hello")
self.assertEqual(post.draft, True)
def test_index(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
factories.DomainFactory.create_batch(2,
enabled=factory.Iterator(
[True, False]))
response = admin.domain_admin_index(request)
self.assertEqual(response.status_code, 200)
expected_domains = models.Domain.objects.all()
self.assertEqual(list(response.context_data["domains"]),
list(expected_domains))
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 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 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 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 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_sum_counters_spreadout(self):
now = timezone.now()
request = MockRequest()
request.META["REMOTE_ADDR"] = "127.0.0.1"
for i in range(settings.REGISTER_LIMIT_COUNT - 1):
key = utils.make_key(request, now - timedelta(minutes=i * 2))
cache.cache.set(key, 1)
request.META["REMOTE_ADDR"] = "127.0.0.2"
for i in range(settings.REGISTER_LIMIT_COUNT - 1):
key = utils.make_key(request, now - timedelta(minutes=i * 2))
cache.cache.set(key, 1)
login_data = {"username": "******", "password1": "qwerty123456", "password2": "qwerty123456"}
response = self.client.post(self.get_url(), login_data)
self.assertNotEqual(response["Location"], self.get_url())
self.assertEqual(get_user_model().objects.count(), 1)
# next attempt should be rejected
response = self.client.post(self.get_url(), login_data)
self.assertEqual(response["Location"], self.get_url())
self.assertEqual(get_user_model().objects.count(), 1)
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 test_sum_counters_spreadout(self):
now = timezone.now()
request = MockRequest()
request.META["REMOTE_ADDR"] = "127.0.0.1"
for i in range(settings.REGISTER_LIMIT_COUNT - 1):
key = utils.make_register_key(request, now - timedelta(minutes=i * 2))
cache.cache.set(key, 1)
request.META["REMOTE_ADDR"] = "127.0.0.2"
for i in range(settings.REGISTER_LIMIT_COUNT - 1):
key = utils.make_register_key(request, now - timedelta(minutes=i * 2))
cache.cache.set(key, 1)
login_data = {"username": "******", "password1": "qwerty123456", "password2": "qwerty123456"}
response = self.client.post(self.get_url(), login_data)
self.assertNotEqual(response["Location"], self.get_url())
self.assertEqual(get_user_model().objects.count(), 1)
# next attempt should be rejected
response = self.client.post(self.get_url(), login_data)
self.assertEqual(response["Location"], self.get_url())
self.assertEqual(get_user_model().objects.count(), 1)
def test_delete_page_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
page = models.HelpBasePage.objects.filter(parent__isnull=False).get()
response = views.delete_page(request, page_pk=page.pk)
self.assertEqual(response.status_code, 200)
# page still exists
page.refresh_from_db()
request.POST["yes_delete"] = True
response = views.delete_page(request, page_pk=page.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response["Location"],
reverse("admin:index", kwargs={"page_pk": page.parent_id}))
# page was deleted
with self.assertRaises(models.HelpBasePage.DoesNotExist):
page.refresh_from_db()
def test_post(self):
request = MockRequest(self.user, has_otp=True, has_sudo=True)
request.method = "POST"
request.POST = {}
post = BlogPostFactory(author=self.user,
draft=True,
subject="no",
body="no")
response = views.blog_admin_edit(request, post.pk)
self.assertEqual(response.status_code, 200)
request.POST = {"subject": "Test", "body": "Hello"}
response = views.blog_admin_edit(request, post.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"],
urlresolvers.reverse("admin:blog:index"))
self.assertEqual(models.BlogPost.objects.count(), 1)
post = models.BlogPost.objects.get()
self.assertEqual(post.subject, "Test")
self.assertEqual(post.body, "Hello")
self.assertEqual(post.draft, False)
def test_make_key_ipv6(self):
now = timezone.now()
now.replace(second=15)
request = MockRequest()
request.META["REMOTE_ADDR"] = "2001:ba8:1f1:f315:216:5eff:fe00:379"
key1 = utils.make_key(request, now)
# a /64 addresses is one per host
request.META["REMOTE_ADDR"] = "2001:ba8:1f1:f315:216:5eff:fe00:380"
key2 = utils.make_key(request, now)
self.assertEqual(key1, key2)
request.META["REMOTE_ADDR"] = "2001:ba8:1f1:f311:216:5eff:fe00:380"
key3 = utils.make_key(request, now)
self.assertNotEqual(key2, key3)
# seconds don't matter
now.replace(second=45)
key4 = utils.make_key(request, now)
self.assertEqual(key3, key4)
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 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_make_key_ipv6(self):
now = timezone.now()
now.replace(second=15)
request = MockRequest()
request.META["REMOTE_ADDR"] = "2001:ba8:1f1:f315:216:5eff:fe00:379"
key1 = utils.make_key(request, now)
# a /64 addresses is one per host
request.META["REMOTE_ADDR"] = "2001:ba8:1f1:f315:216:5eff:fe00:380"
key2 = utils.make_key(request, now)
self.assertEqual(key1, key2)
request.META["REMOTE_ADDR"] = "2001:ba8:1f1:f311:216:5eff:fe00:380"
key3 = utils.make_key(request, now)
self.assertNotEqual(key2, key3)
# seconds don't matter
now.replace(second=45)
key4 = utils.make_key(request, now)
self.assertEqual(key3, key4)
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)
