class TestOrganizationAddForm(TestCase):
"""
Tests for adding new organizations
"""
def setUp(self):
self.factory = RequestFactory()
def test_expected_valid_data_validates(self):
"""Test our happy path"""
request = self.factory.request()
form = OrganizationAddForm(
request,
data={
"slug": "new_org",
"name": "New Org",
"email": "*****@*****.**"
},
)
self.assertTrue(form.is_valid())
def test_add_organization_for_existing_user(self):
user = User.objects.create_user("timmy",
password="******",
email="*****@*****.**")
request = self.factory.request()
form = OrganizationAddForm(request,
data={
"slug": "new_org",
"name": "New Org",
"email": user.email
})
self.assertTrue(form.is_valid())
new_org = form.save()
self.assertTrue(new_org.is_active)
self.assertEqual(new_org.name, "New Org")
def test_add_organization_for_new_user(self):
user = User.objects.create_user("timmy",
password="******",
email="*****@*****.**")
request = request_factory_login(self.factory, user)
form = OrganizationAddForm(
request,
data={
"slug": "new_org",
"name": "New Org",
"email": "*****@*****.**",
},
)
self.assertTrue(form.is_valid())
new_org = form.save()
self.assertFalse(new_org.is_active) # Inactive until confirmation
def test_send_mail(self, fake_messages):
"""Test EmailRepsForm email sending functionality."""
fake_messages.expects('success')
data = {
'subject': 'Test email subject',
'body': 'Test email body',
'functional_area': self.functional_area.id
}
form = EmailRepsForm(data=data)
ok_(form.is_valid())
area = self.functional_area
UserFactory.create_batch(20, userprofile__functional_areas=[area])
factory = RequestFactory()
request = factory.request()
request.user = UserFactory.create()
reps = User.objects.filter(userprofile__functional_areas__name=area)
form.send_email(request, reps)
eq_(len(mail.outbox), 1)
address = lambda u: '%s %s <%s>' % (u.first_name, u.last_name, u.email)
recipients = map(address, reps)
eq_(set(mail.outbox[0].to), set(recipients))
eq_(mail.outbox[0].subject, data['subject'])
eq_(mail.outbox[0].body, data['body'])
def test_send_mail(self, fake_messages):
"""Test EmailRepsForm email sending functionality."""
data = {"subject": "Test email subject", "body": "Test email body", "functional_area": self.functional_area.id}
form = EmailRepsForm(data=data)
ok_(form.is_valid())
area = self.functional_area
UserFactory.create_batch(20, userprofile__functional_areas=[area])
factory = RequestFactory()
request = factory.request()
request.user = UserFactory.create()
reps = User.objects.filter(userprofile__functional_areas__name=area)
form.send_email(request, reps)
eq_(len(mail.outbox), 20)
address = lambda u: "%s %s <%s>" % (u.first_name, u.last_name, u.email)
recipients = map(address, reps)
receivers = []
for i in range(0, len(mail.outbox)):
eq_(mail.outbox[i].subject, data["subject"])
eq_(mail.outbox[i].body, data["body"])
receivers.append(mail.outbox[i].to[0])
eq_(set(receivers), set(recipients))
fake_messages.assert_called_with(ANY, "Email sent successfully.")
def test_send_mail(self, fake_messages):
"""Test EmailRepsForm email sending functionality."""
data = {'subject': 'Test email subject',
'body': 'Test email body',
'functional_area': self.functional_area.id}
form = EmailRepsForm(data=data)
ok_(form.is_valid())
area = self.functional_area
UserFactory.create_batch(20, userprofile__functional_areas=[area])
factory = RequestFactory()
request = factory.request()
request.user = UserFactory.create()
reps = User.objects.filter(userprofile__functional_areas__name=area)
form.send_email(request, reps)
eq_(len(mail.outbox), 20)
def format_name(user):
return '%s %s <%s>' % (user.first_name, user.last_name, user.email)
recipients = map(format_name, reps)
receivers = []
for i in range(0, len(mail.outbox)):
eq_(mail.outbox[i].subject, data['subject'])
eq_(mail.outbox[i].body, data['body'])
receivers.append(mail.outbox[i].to[0])
eq_(set(receivers), set(recipients))
fake_messages.assert_called_with(ANY, 'Email sent successfully.')
class AddDecisionTest(DecisionTestCase):
fixtures = ['organizations.json', 'users.json']
def setUp(self):
self.betty = User.objects.get(username="******")
self.bettysorg = Organization.objects.get_for_user(self.betty)[0]
self.factory = RequestFactory()
def test_jquery_javascript_included_in_page(self):
response = self.load_add_decision_and_return_response()
self.assertContains(response, "jquery.min.js")
self.assertContains(response, "jquery-ui.min.js")
def test_jquery_css_included_in_page(self):
response = self.load_add_decision_and_return_response()
self.assertContains(response, "jquery-ui.css")
def test_add_description_form_doesnt_ask_for_name(self):
response = self.load_add_decision_and_return_response()
self.assertNotContains(response, "id_short_name")
def load_add_decision_and_return_response(self):
request = self.factory.request()
request.user = self.betty
kwargs = {'org_slug':self.bettysorg.slug}
response = DecisionCreate(template_name='decision_update_page.html').dispatch(request, **kwargs)
rendered_response = response.render()
return rendered_response
def request(self, **request_args):
"""Constructs a generic request object, INCLUDING middleware modifications."""
from django.core import urlresolvers
request = RequestFactory.request(self, **request_args)
###pprint.pprint(request)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
#print("APPLYING REQUEST MIDDLEWARE ", middleware_method, file=sys.stderr)
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
urlconf = settings.ROOT_URLCONF
urlresolvers.set_urlconf(urlconf)
resolver = urlresolvers.RegexURLResolver(r'^/', urlconf)
callback, callback_args, callback_kwargs = resolver.resolve(
request.path_info)
# Apply view middleware
for middleware_method in handler._view_middleware:
#print("APPLYING VIEW MIDDLEWARE ", middleware_method, file=sys.stderr)
response = middleware_method(request, callback, callback_args, callback_kwargs)
if response:
raise Exception("Couldn't create request mock object - "
"view middleware returned a response")
return request
def handle(self, *args, **options):
base_url = options.get('base_url', '')
if base_url is '':
# compress all found themes, without touching database, as database is not ready normally.
site = Site(domain='example.com')
all_sitethemes = [SiteTheme(theme_slug=slug, site=site)
for slug in os.listdir(settings.THEMING_ROOT)
if os.path.isdir(os.path.join(settings.THEMING_ROOT, slug))]
else:
factory = RequestFactory()
self.request = request = factory.request()
request.META['SERVER_NAME'] = urlparse(base_url).netloc
request.user = User(is_superuser=False)
try:
from aliassite.middleware import AliasSiteMiddleware
AliasSiteMiddleware().process_request(request)
except ImportError:
pass
ThemingMiddleware().process_request(request)
sitetheme = get_thread_variable('sitetheme')
all_sitethemes = [sitetheme, ]
for sitetheme in all_sitethemes:
if sitetheme is None:
print('# cannot find any sitetheme, fall back to pure compress command')
else:
print('# Run compress command for Site:%s Theme:%s' % (sitetheme.site, sitetheme.theme))
set_thread_variable('sitetheme', sitetheme)
super(Command, self).handle(*args, **options)
def test_send_mail(self, fake_messages):
"""Test EmailRepsForm email sending functionality."""
data = {'subject': 'Test email subject',
'body': 'Test email body',
'functional_area': self.functional_area.id}
form = EmailRepsForm(data=data)
ok_(form.is_valid())
area = self.functional_area
UserFactory.create_batch(20, userprofile__functional_areas=[area])
factory = RequestFactory()
request = factory.request()
request.user = UserFactory.create()
reps = User.objects.filter(userprofile__functional_areas__name=area)
form.send_email(request, reps)
eq_(len(mail.outbox), 1)
address = lambda u: '%s %s <%s>' % (u.first_name, u.last_name, u.email)
recipients = map(address, reps)
eq_(set(mail.outbox[0].to), set(recipients))
eq_(mail.outbox[0].subject, data['subject'])
eq_(mail.outbox[0].body, data['body'])
fake_messages.assert_called_with(ANY, 'Email sent successfully.')
def test_cookie_monitoring_no_groups(self, mock_set_custom_attribute,
mock_capture_cookie_sizes):
mock_capture_cookie_sizes.is_enabled.return_value = True
middleware = CookieMonitoringMiddleware()
cookies_dict = {
"a": "." * 10,
"b": "." * 15,
}
factory = RequestFactory()
for name, value in cookies_dict.items():
factory.cookies[name] = value
mock_request = factory.request()
middleware.process_request(mock_request)
mock_set_custom_attribute.assert_has_calls([
call('cookies.max.name', 'b'),
call('cookies.max.size', 15),
call('cookies.1.name', 'b'),
call('cookies.1.size', 15),
call('cookies.2.name', 'a'),
call('cookies.2.size', 10),
call('cookies_total_size', 25),
],
any_order=True)
def test_begin_login_with_xrds_url(self):
# the provider URL must be converted to an absolute URL in order to be
# used as an openid provider.
provider_url = reverse('openid-provider-xrds')
factory = RequestFactory()
request = factory.request()
abs_provider_url = request.build_absolute_uri(location=provider_url)
# In order for this absolute URL to work (i.e. to get xrds, then authentication)
# in the test environment, we either need a live server that works with the default
# fetcher (i.e. urlopen2), or a test server that is reached through a custom fetcher.
# Here we do the latter:
fetcher = MyFetcher(self.client)
openid.fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False)
# now we can begin the login process by invoking a local openid client,
# with a pointer to the (also-local) openid provider:
with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url):
url = reverse('openid-login')
resp = self.client.post(url)
code = 200
self.assertEqual(
resp.status_code, code,
"got code {0} for url '{1}'. Expected code {2}".format(
resp.status_code, url, code))
class LoginViewTestCase(unittest.TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_get(self):
request = self.factory.get(reverse("account_login"))
request.user = AnonymousUser()
response = LoginView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.template_name, ["account/login.html"])
def test_get_disabled(self):
request = self.factory.get(reverse("account_login"))
request.user = AnonymousUser()
response = LoginDisabledView.as_view()(request)
self.assertEqual(response.status_code, 200)
def test_post_disabled(self):
request = self.factory.post(reverse("account_login"))
request.user = AnonymousUser()
response = LoginDisabledView.as_view()(request)
self.assertEqual(response.status_code, 403)
def test_custom_redirect_field(self):
request = self.factory.request()
request.GET = {"next_page": "/profile/"}
form = LoginUsernameForm({"username": "******", "password": "******"})
view = LoginRedirectView(request=request, redirect_field_name="next_page")
self.assertEqual("/profile/", view.form_valid(form)["Location"])
def test_begin_login_with_xrds_url(self):
# the provider URL must be converted to an absolute URL in order to be
# used as an openid provider.
provider_url = reverse('openid-provider-xrds')
factory = RequestFactory()
request = factory.request()
abs_provider_url = request.build_absolute_uri(location=provider_url)
# In order for this absolute URL to work (i.e. to get xrds, then authentication)
# in the test environment, we either need a live server that works with the default
# fetcher (i.e. urlopen2), or a test server that is reached through a custom fetcher.
# Here we do the latter:
fetcher = MyFetcher(self.client)
openid.fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False)
# now we can begin the login process by invoking a local openid client,
# with a pointer to the (also-local) openid provider:
with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url):
url = reverse('openid-login')
resp = self.client.post(url)
code = 200
self.assertEqual(resp.status_code, code,
"got code {0} for url '{1}'. Expected code {2}"
.format(resp.status_code, url, code))
def testGetSubdomainMiddleware5(self):
"Test GetSubdomainMiddleware.process_request populates the variables we need correctly"
rf = RequestFactory(domain = 'boox.notfoo.tld')
request = rf.request()
middleware = GetSubdomainMiddleware()
middleware.process_request(request)
self.assertEqual(request.META['domain'], 'boox.notfoo.tld')
class LoginViewTestCase(unittest.TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_get(self):
request = self.factory.get(reverse("account_login"))
request.user = AnonymousUser()
response = LoginView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.template_name, ["account/login.html"])
def test_get_disabled(self):
request = self.factory.get(reverse("account_login"))
request.user = AnonymousUser()
response = LoginDisabledView.as_view()(request)
self.assertEqual(response.status_code, 200)
def test_post_disabled(self):
request = self.factory.post(reverse("account_login"))
request.user = AnonymousUser()
response = LoginDisabledView.as_view()(request)
self.assertEqual(response.status_code, 403)
def test_custom_redirect_field(self):
request = self.factory.request()
request.GET = {"next_page": "/profile/"}
form = LoginUsernameForm({"username": "******", "password": "******"})
view = LoginRedirectView(request=request,
redirect_field_name="next_page")
self.assertEqual("/profile/", view.form_valid(form)["Location"])
def setUp(self):
site_navbars._registry = {}
self.user = User.objects.create_superuser("user_login",
"*****@*****.**", "pass")
rf = RequestFactory()
self.request = rf.request()
self.request.user = self.user
def testGetSubdomainMiddleware2(self):
"Test GetSubdomainMiddleware.process_request populates the variables we need correctly"
rf = RequestFactory(subdomain = 'www')
request = rf.request()
middleware = GetSubdomainMiddleware()
middleware.process_request(request)
self.assertEqual(request.META['subdomain'], 'www')
self.assertEqual(request.subdomain, None)
def get_mock_request(self, cookies_dict):
"""
Return mock request with the provided cookies in the header.
"""
factory = RequestFactory()
for name, value in cookies_dict.items():
factory.cookies[name] = value
return factory.request()
def request(self, **request):
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
for mw in handler._request_middleware:
if mw(request):
raise Exception('middleware returned a reponse')
return request
def test_cookie_monitoring(self, mock_set_custom_attribute,
mock_capture_cookie_sizes):
mock_capture_cookie_sizes.is_enabled.return_value = True
middleware = CookieMonitoringMiddleware()
cookies_dict = {
"a": "." * 100,
"_b": "." * 13,
"_c_": "." * 13,
"a.b": "." * 10,
"a.c": "." * 10,
"b.": "." * 13,
"b_a": "." * 15,
"b_c": "." * 15,
"d": "." * 3,
}
factory = RequestFactory()
for name, value in cookies_dict.items():
factory.cookies[name] = value
mock_request = factory.request()
middleware.process_request(mock_request)
mock_set_custom_attribute.assert_has_calls([
call('cookies.1.name', 'a'),
call('cookies.1.size', 100),
call('cookies.2.name', 'b_a'),
call('cookies.2.size', 15),
call('cookies.3.name', 'b_c'),
call('cookies.3.size', 15),
call('cookies.4.name', '_b'),
call('cookies.4.size', 13),
call('cookies.5.name', '_c_'),
call('cookies.5.size', 13),
call('cookies.6.name', 'b.'),
call('cookies.6.size', 13),
call('cookies.7.name', 'a.b'),
call('cookies.7.size', 10),
call('cookies.8.name', 'a.c'),
call('cookies.8.size', 10),
call('cookies.group.1.name', 'b'),
call('cookies.group.1.size', 43),
call('cookies.group.2.name', 'a'),
call('cookies.group.2.size', 20),
call('cookies.max.name', 'a'),
call('cookies.max.size', 100),
call('cookies.max.group.name', 'a'),
call('cookies.max.group.size', 100),
call('cookies_total_size', 192),
call('cookies_unaccounted_size', 3),
call('cookies_total_num', 9),
call('cookies.header.size', 238)
],
any_order=True)
def testGetSubdomainMiddleware3(self):
"Test GetSubdomainMiddleware.process_request populates the variables we need correctly"
user = User.objects.create_user(username = '******', password = '******', email = '*****@*****.**')
subdomain = Subdomain.objects.register_new_subdomain(subdomain_text = 'foo4', name='Foo, the subdomain', description = 'Foo has not description', user = user)
rf = RequestFactory(subdomain = 'foo4')
request = rf.request()
middleware = GetSubdomainMiddleware()
middleware.process_request(request)
self.assertEqual(request.META['subdomain'], 'foo4')
def request(self, **request):
"Construct a generic request object."
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request mock object - " "request middleware returned a response")
return request
def test_replace_parameters(self):
from django_boost.templatetags.boost_url import replace_parameters
cases = [
("", ('p', 'p'), ("p=p", )),
("q=q", ('p', 'p'), ("q=q", "p=p")),
("q=q", ('q', 'x', 'p', 'p'), ("q=x", "p=p")),
]
factory = RequestFactory()
for qs, args, expected in cases:
request = factory.request(**{'QUERY_STRING': qs})
actual = replace_parameters(request, *args)
for e in expected:
self.assertIn(e, actual)
with self.assertRaises(LookupError):
request = factory.request()
replace_parameters(request, 'q')
class InvitationTests(TestCase):
fixtures = ['users.json', 'orgs.json']
def setUp(self):
mail.outbox = []
self.factory = RequestFactory()
self.tokenizer = RegistrationTokenGenerator()
self.user = User.objects.get(username="******")
self.pending_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.pending_user.is_active = False
self.pending_user.save()
def test_backend_definition(self):
from organizations.backends import invitation_backend
self.assertTrue(isinstance(invitation_backend(), InvitationBackend))
def test_create_user(self):
invited = InvitationBackend().invite_by_email("*****@*****.**")
self.assertTrue(isinstance(invited, User))
self.assertFalse(invited.is_active)
self.assertEqual(1, len(mail.outbox))
mail.outbox = []
def test_create_existing_user(self):
invited = InvitationBackend().invite_by_email(self.user.email)
self.assertEqual(self.user, invited)
self.assertEqual(0, len(mail.outbox)) # User is active
def test_send_reminder(self):
InvitationBackend().send_reminder(self.pending_user)
self.assertEqual(1, len(mail.outbox))
InvitationBackend().send_reminder(self.user)
self.assertEqual(1, len(mail.outbox)) # User is active
mail.outbox = []
def test_urls(self):
"""Ensure no error is raised"""
reverse('invitations_register',
kwargs={
'user_id': self.pending_user.id,
'token': self.tokenizer.make_token(self.pending_user)
})
def test_activate_user(self):
request = self.factory.request()
with self.assertRaises(Http404):
InvitationBackend().activate_view(
request, self.user.id, self.tokenizer.make_token(self.user))
self.assertEqual(
200,
InvitationBackend().activate_view(
request, self.pending_user.id,
self.tokenizer.make_token(self.pending_user)).status_code)
def test_begin_login_with_login_url(self):
# the provider URL must be converted to an absolute URL in order to be
# used as an openid provider.
provider_url = reverse('openid-provider-login')
factory = RequestFactory()
request = factory.request()
abs_provider_url = request.build_absolute_uri(location=provider_url)
# In order for this absolute URL to work (i.e. to get xrds, then authentication)
# in the test environment, we either need a live server that works with the default
# fetcher (i.e. urlopen2), or a test server that is reached through a custom fetcher.
# Here we do the latter:
fetcher = MyFetcher(self.client)
openid.fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False)
# now we can begin the login process by invoking a local openid client,
# with a pointer to the (also-local) openid provider:
with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url):
url = reverse('openid-login')
resp = self.client.post(url)
code = 200
self.assertEqual(
resp.status_code, code,
"got code {0} for url '{1}'. Expected code {2}".format(
resp.status_code, url, code))
for expected_input in (
'<input name="openid.ns" type="hidden" value="http://specs.openid.net/auth/2.0" />',
'<input name="openid.ns.ax" type="hidden" value="http://openid.net/srv/ax/1.0" />',
'<input name="openid.ax.type.fullname" type="hidden" value="http://axschema.org/namePerson" />',
'<input type="submit" value="Continue" />',
'<input name="openid.ax.type.email" type="hidden" value="http://axschema.org/contact/email" />',
'<input name="openid.ax.type.lastname" '
'type="hidden" value="http://axschema.org/namePerson/last" />',
'<input name="openid.ax.type.firstname" '
'type="hidden" value="http://axschema.org/namePerson/first" />',
'<input name="openid.ax.required" type="hidden" '
'value="email,fullname,old_email,firstname,old_nickname,lastname,old_fullname,nickname" />',
'<input name="openid.ax.type.nickname" '
'type="hidden" value="http://axschema.org/namePerson/friendly" />',
'<input name="openid.ax.type.old_email" '
'type="hidden" value="http://schema.openid.net/contact/email" />',
'<input name="openid.ax.type.old_nickname" '
'type="hidden" value="http://schema.openid.net/namePerson/friendly" />',
'<input name="openid.ax.type.old_fullname" '
'type="hidden" value="http://schema.openid.net/namePerson" />',
'<input name="openid.identity" '
'type="hidden" value="http://specs.openid.net/auth/2.0/identifier_select" />',
'<input name="openid.claimed_id" '
'type="hidden" value="http://specs.openid.net/auth/2.0/identifier_select" />',
# should work on the test server as well
'<input name="openid.realm" '
'type="hidden" value="http://testserver/" />',
):
self.assertContains(resp, expected_input, html=True)
def request(self, **request):
"""Construct a generic request object."""
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
return request
def request(self, **request):
# https://gist.github.com/tschellenbach/925270
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
return request
def request(self, **request):
#https://gist.github.com/tschellenbach/925270
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
return request
def request(self, **request_args):
"""Constructs a generic request object, INCLUDING middleware modifications."""
from django.core import urlresolvers
request = RequestFactory.request(self, **request_args)
###pprint.pprint(request)
utilities.make_request_querydicts_mutable(request)
request.session = DJANGO_TEST_CLIENT.session # hack
# we mimick django authentication middleware
from django.contrib.auth.models import AnonymousUser
request.user = AnonymousUser() # default
# we mimick messages middleware
from django.contrib.messages.storage import default_storage
request._messages = default_storage(request)
# we mimick ZODB middleware
datamanager = retrieve_game_instance(
game_instance_id=TEST_GAME_INSTANCE_ID,
request=request,
update_timestamp=False)
request.datamanager = datamanager # for template tags and the likes
""" Old version, before Django2.0 middlewares
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
#print("APPLYING REQUEST MIDDLEWARE ", middleware_method, file=sys.stderr)
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
urlconf = settings.ROOT_URLCONF
urlresolvers.set_urlconf(urlconf)
resolver = urlresolvers.RegexURLResolver(r'^/', urlconf)
callback, callback_args, callback_kwargs = resolver.resolve(
request.path_info)
# Apply view middleware
for middleware_method in handler._view_middleware:
#print("APPLYING VIEW MIDDLEWARE ", middleware_method, file=sys.stderr)
response = middleware_method(request, callback, callback_args, callback_kwargs)
if response:
raise Exception("Couldn't create request mock object - "
"view middleware returned a response")
"""
return request
def testensure_is_main_subdomain2(self):
def view_func(request):
"Dummy view function to decorate"
return HttpResponse('hello')
view_func = ensure_is_main_subdomain(view_func)
rf = RequestFactory(subdomain = 'bar')
request = rf.request()
middleware = GetSubdomainMiddleware()
middleware.process_request(request)
response = view_func(request)
self.assertEqual(HttpResponseRedirect, response.__class__)
def testpopulate_subdomain(self):
user = User.objects.create_user(username = '******', password = '******', email = '*****@*****.**')
subdomain = Subdomain.objects.register_new_subdomain(subdomain_text = 'foo5', name='Foo, the subdomain', description = 'Foo has not description', user = user)
rf = RequestFactory(subdomain = 'foo5', main_site = False)
request = rf.request()
middleware = GetSubdomainMiddleware()
middleware.process_request(request)
context = populate_subdomain(request)
self.assertEqual(context['subdomain_text'], 'testserver')
self.assertEqual(context['main_site'], False)
self.assertEqual(context['subdomain'], None)
def request(self, **request):
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
# call each middleware in turn and throw away any responses that they might return
for middleware_path in settings.MIDDLEWARE:
middleware = import_string(middleware_path)(handler)
if hasattr(middleware, 'process_request'):
middleware.process_request(request)
return request
def test_get_querystring(self):
from django_boost.templatetags.boost_url import get_querystring
cases = [
("", "q", None),
("q=q", "q", "q"),
("q=q&q=j&q=k", "q", "k"),
]
factory = RequestFactory()
for qs, key, value in cases:
request = factory.request(**{'QUERY_STRING': qs})
self.assertEqual(get_querystring(request, key), value)
def CreatePreparedExistentEntityAuthRequest():
factory = RequestFactory()
data = '[{"type":"dbModel.shape.DBTable","id":"465bf0b2-a50f-f6cb-fdf0-0cbf142d239b","x":20,"y":20,"width":99,"height":57.84375,"userData":{},"cssClass":"DBTable","bgColor":"#DBDDDE","color":"#D7D7D7","stroke":1,"alpha":1,"radius":3,"tableName":"TableName10","tablePorts":[],"attributes":[{"text":"new attribute0","id":"b3177ad1-b220-805e-e748-be12434e578d","datatype":"string","pk":true,"fk":false,"isRequired":true,"isNullable":false}]}]'
auth = authenticate(username='******', password='******')
request = factory.request()
request._body = data
request._get = {"projectID":1, "diagramID":1}
request.user = auth
return request
def request(self, **request):
from django.core.handlers.base import BaseHandler
"Construct a generic request object."
request['REQUEST'] = dict()
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
return request
def CreatePreparedExistentEntityAuthRequest():
factory = RequestFactory()
data = '[{"type":"dbModel.shape.DBTable","id":"465bf0b2-a50f-f6cb-fdf0-0cbf142d239b","x":20,"y":20,"width":99,"height":57.84375,"userData":{},"cssClass":"DBTable","bgColor":"#DBDDDE","color":"#D7D7D7","stroke":1,"alpha":1,"radius":3,"tableName":"TableName10","tablePorts":[],"attributes":[{"text":"new attribute0","id":"b3177ad1-b220-805e-e748-be12434e578d","datatype":"string","pk":true,"fk":false,"isRequired":true,"isNullable":false}]}]'
auth = authenticate(username='******', password='******')
request = factory.request()
request._body = data
request._get = {"projectID": 1, "diagramID": 1}
request.user = auth
return request
def request(self, **request):
from django.core.handlers.base import BaseHandler
"Construct a generic request object."
request['REQUEST'] = dict()
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
return request
class InvitationTests(TestCase):
fixtures = ['users.json', 'orgs.json']
def setUp(self):
mail.outbox = []
self.factory = RequestFactory()
self.tokenizer = RegistrationTokenGenerator()
self.user = User.objects.get(username="******")
self.pending_user = User.objects.create_user(username="******",
email="*****@*****.**", password="******")
self.pending_user.is_active = False
self.pending_user.save()
def test_backend_definition(self):
from organizations.backends import invitation_backend
self.assertTrue(isinstance(invitation_backend(), InvitationBackend))
def test_create_user(self):
invited = InvitationBackend().invite_by_email("*****@*****.**")
self.assertTrue(isinstance(invited, User))
self.assertFalse(invited.is_active)
self.assertEqual(1, len(mail.outbox))
mail.outbox = []
def test_create_existing_user(self):
invited = InvitationBackend().invite_by_email(self.user.email)
self.assertEqual(self.user, invited)
self.assertEqual(0, len(mail.outbox)) # User is active
def test_send_reminder(self):
InvitationBackend().send_reminder(self.pending_user)
self.assertEqual(1, len(mail.outbox))
InvitationBackend().send_reminder(self.user)
self.assertEqual(1, len(mail.outbox)) # User is active
mail.outbox = []
def test_urls(self):
"""Ensure no error is raised"""
reverse('invitations_register', kwargs={
'user_id': self.pending_user.id,
'token': self.tokenizer.make_token(self.pending_user)})
def test_activate_user(self):
request = self.factory.request()
with self.assertRaises(Http404):
InvitationBackend().activate_view(request, self.user.id,
self.tokenizer.make_token(self.user))
self.assertEqual(200, InvitationBackend().activate_view(request,
self.pending_user.id,
self.tokenizer.make_token(
self.pending_user)).status_code)
def testensure_has_subdomain2(self):
def view_func(request):
"Dummy view function to decorate"
return HttpResponse('hello')
view_func = ensure_has_subdomain(view_func)
user = User.objects.create_user(username = '******', password = '******', email = '*****@*****.**')
subdomain = Subdomain.objects.register_new_subdomain(subdomain_text = 'foo7', name='Foo, the subdomain', description = 'Foo has not description', user = user)
rf = RequestFactory(subdomain = 'doesnotexistxx')
request = rf.request()
middleware = GetSubdomainMiddleware()
middleware.process_request(request)
response = view_func(request)
self.assertEqual(HttpResponseRedirect, response.__class__)
def request(self, **request):
"Construct a generic request object."
request = RequestFactory.request(self, **request)
handler = BaseHandler()
handler.load_middleware()
# BaseHandler_request_middleware is not set in Django2.0
# and removed in Django2.1
if sys.version_info[0] < 2:
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
return request
class SignupViewTestCase(unittest.TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_get(self):
request = self.factory.get(reverse("account_signup"))
request.user = AnonymousUser()
response = SignupEnabledView.as_view()(request)
self.assertEqual(response.status_code, 200)
def test_get_disabled(self):
request = self.factory.get(reverse("account_signup"))
request.user = AnonymousUser()
response = SignupDisabledView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.template_name, "account/signup_closed.html")
def test_post_disabled(self):
request = self.factory.post(reverse("account_signup"))
request.user = AnonymousUser()
response = SignupDisabledView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.template_name, "account/signup_closed.html")
def test_post_successful(self):
post = {
"username": "******",
"password": "******",
"password_confirm": "pwd",
"email": "*****@*****.**"
}
request = self.factory.post(reverse("account_signup"), post)
request.user = AnonymousUser()
response = SignupEnabledView.as_view()(request)
self.assertEqual(response.status_code, 302)
user = User.objects.get(username="******")
self.asserEqual(user.email, "*****@*****.**")
def test_custom_redirect_field(self):
request = self.factory.request()
request.GET = {"next_page": "/profile/"}
form = SignupForm({
"username": "******",
"password": "******",
"password_confirm": "password",
"email": "*****@*****.**",
})
view = SignupRedirectView(request=request,
redirect_field_name="next_page")
self.assertEqual("/profile/", view.form_valid(form)["Location"])
def test_basic_cookie_monitoring(self, mock_set_custom_attribute, mock_capture_cookie_sizes):
mock_capture_cookie_sizes.is_enabled.return_value = False
middleware = CookieMonitoringMiddleware()
cookies_dict = {'a': 'b'}
factory = RequestFactory()
for name, value in cookies_dict.items():
factory.cookies[name] = value
mock_request = factory.request()
middleware.process_request(mock_request)
mock_set_custom_attribute.assert_called_once_with('cookies.header.size', 3)
def _send_bad_redirection_login(self):
"""
Attempt to log in to the provider with setup parameters
Intentionally fail the login to force a redirect
"""
user = UserFactory()
factory = RequestFactory()
post_params = {"email": user.email, "password": "******"}
fake_url = "fake url"
request = factory.post(reverse("openid-provider-login"), post_params)
openid_setup = {"request": factory.request(), "url": fake_url, "post_params": {}}
request.session = {"openid_setup": openid_setup}
response = provider_login(request)
return response
class TestElasticstack(TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_form_kwargs(self):
"""Ensure request data updates the form kwargs"""
request = self.factory.request()
request.GET = {'q': "whoami"}
mixin = views.SearchMixin()
mixin.request = request
mixin.queryset = [] # An EmptySearchQuerySet is basically an empty list
self.assertEqual(mixin.get_form_kwargs(),
{'initial': {}, 'data': request.GET, 'searchqueryset': []})
def simulate_login(username, password, headers=None):
rf = RequestFactory()
request = rf.request(**headers)
engine = import_module(settings.SESSION_ENGINE)
request.session = engine.SessionStore()
# TODO remove when we don't support Django 1.10 anymore
# request passed in to authenticate only after Django 1.10
# Also the middleware saving the request to thread local can be dropped
try:
user = authenticate(request, username=username, password=password)
except TypeError:
middleware.thread_data.request = request
user = authenticate(username=username, password=password)
if user:
login(request, user)
def _send_bad_redirection_login(self):
"""
Attempt to log in to the provider with setup parameters
Intentionally fail the login to force a redirect
"""
user = UserFactory()
factory = RequestFactory()
post_params = {'email': user.email, 'password': '******'}
fake_url = 'fake url'
request = factory.post(reverse('openid-provider-login'), post_params)
openid_setup = {'request': factory.request(), 'url': fake_url}
request.session = {'openid_setup': openid_setup}
response = provider_login(request)
return response
class SignupViewTestCase(unittest.TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_get(self):
request = self.factory.get(reverse("account_signup"))
request.user = AnonymousUser()
response = SignupEnabledView.as_view()(request)
self.assertEqual(response.status_code, 200)
def test_get_disabled(self):
request = self.factory.get(reverse("account_signup"))
request.user = AnonymousUser()
response = SignupDisabledView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.template_name, "account/signup_closed.html")
def test_post_disabled(self):
request = self.factory.post(reverse("account_signup"))
request.user = AnonymousUser()
response = SignupDisabledView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.template_name, "account/signup_closed.html")
def test_post_successful(self):
post = {"username": "******", "password": "******",
"password_confirm": "pwd", "email": "*****@*****.**"}
request = self.factory.post(reverse("account_signup"), post)
request.user = AnonymousUser()
response = SignupEnabledView.as_view()(request)
self.assertEqual(response.status_code, 302)
user = User.objects.get(username="******")
self.asserEqual(user.email, "*****@*****.**")
def test_custom_redirect_field(self):
request = self.factory.request()
request.GET = {"next_page": "/profile/"}
form = SignupForm({
"username": "******",
"password": "******",
"password_confirm": "password",
"email": "*****@*****.**",
})
view = SignupRedirectView(request=request, redirect_field_name="next_page")
form.is_valid()
self.assertEqual("/profile/", view.form_valid(form)["Location"])
def test_begin_login(self):
# the provider URL must be converted to an absolute URL in order to be
# used as an openid provider.
provider_url = reverse('openid-provider-xrds')
factory = RequestFactory()
request = factory.request()
abs_provider_url = request.build_absolute_uri(location=provider_url)
# now we can begin the login process by invoking a local openid client,
# with a pointer to the (also-local) openid provider:
with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url):
url = reverse('openid-login')
resp = self.client.post(url)
code = 200
self.assertEqual(resp.status_code, code,
"got code {0} for url '{1}'. Expected code {2}"
.format(resp.status_code, url, code))
def testBeginLoginWithLoginUrl(self):
# skip the test if openid is not enabled (as in cms.envs.test):
if not settings.MITX_FEATURES.get('AUTH_USE_OPENID') or not settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'):
return
# the provider URL must be converted to an absolute URL in order to be
# used as an openid provider.
provider_url = reverse('openid-provider-login')
factory = RequestFactory()
request = factory.request()
abs_provider_url = request.build_absolute_uri(location=provider_url)
# In order for this absolute URL to work (i.e. to get xrds, then authentication)
# in the test environment, we either need a live server that works with the default
# fetcher (i.e. urlopen2), or a test server that is reached through a custom fetcher.
# Here we do the latter:
fetcher = MyFetcher(self.client)
openid.fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False)
# now we can begin the login process by invoking a local openid client,
# with a pointer to the (also-local) openid provider:
with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url):
url = reverse('openid-login')
resp = self.client.post(url)
code = 200
self.assertEqual(resp.status_code, code,
"got code {0} for url '{1}'. Expected code {2}"
.format(resp.status_code, url, code))
self.assertContains(resp, '<input name="openid.mode" type="hidden" value="checkid_setup" />', html=True)
self.assertContains(resp, '<input name="openid.ns" type="hidden" value="http://specs.openid.net/auth/2.0" />', html=True)
self.assertContains(resp, '<input name="openid.identity" type="hidden" value="http://specs.openid.net/auth/2.0/identifier_select" />', html=True)
self.assertContains(resp, '<input name="openid.claimed_id" type="hidden" value="http://specs.openid.net/auth/2.0/identifier_select" />', html=True)
self.assertContains(resp, '<input name="openid.ns.ax" type="hidden" value="http://openid.net/srv/ax/1.0" />', html=True)
self.assertContains(resp, '<input name="openid.ax.mode" type="hidden" value="fetch_request" />', html=True)
self.assertContains(resp, '<input name="openid.ax.required" type="hidden" value="email,fullname,old_email,firstname,old_nickname,lastname,old_fullname,nickname" />', html=True)
self.assertContains(resp, '<input name="openid.ax.type.fullname" type="hidden" value="http://axschema.org/namePerson" />', html=True)
self.assertContains(resp, '<input name="openid.ax.type.lastname" type="hidden" value="http://axschema.org/namePerson/last" />', html=True)
self.assertContains(resp, '<input name="openid.ax.type.firstname" type="hidden" value="http://axschema.org/namePerson/first" />', html=True)
self.assertContains(resp, '<input name="openid.ax.type.nickname" type="hidden" value="http://axschema.org/namePerson/friendly" />', html=True)
self.assertContains(resp, '<input name="openid.ax.type.email" type="hidden" value="http://axschema.org/contact/email" />', html=True)
self.assertContains(resp, '<input name="openid.ax.type.old_email" type="hidden" value="http://schema.openid.net/contact/email" />', html=True)
self.assertContains(resp, '<input name="openid.ax.type.old_nickname" type="hidden" value="http://schema.openid.net/namePerson/friendly" />', html=True)
self.assertContains(resp, '<input name="openid.ax.type.old_fullname" type="hidden" value="http://schema.openid.net/namePerson" />', html=True)
self.assertContains(resp, '<input type="submit" value="Continue" />', html=True)
# this should work on the server:
self.assertContains(resp, '<input name="openid.realm" type="hidden" value="http://testserver/" />', html=True)
def test_log_encrypted_cookies_no_key(self, mock_encrypt,
mock_capture_cookie_sizes):
middleware = CookieMonitoringMiddleware()
cookies_dict = {
"a": "." * 10,
"b": "." * 15,
}
factory = RequestFactory()
for name, value in cookies_dict.items():
factory.cookies[name] = value
mock_request = factory.request()
middleware.process_request(mock_request)
mock_encrypt.assert_not_called()
def test_begin_login(self):
# the provider URL must be converted to an absolute URL in order to be
# used as an openid provider.
provider_url = reverse('openid-provider-xrds')
factory = RequestFactory()
request = factory.request()
abs_provider_url = request.build_absolute_uri(location=provider_url)
# now we can begin the login process by invoking a local openid client,
# with a pointer to the (also-local) openid provider:
with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url):
url = reverse('openid-login')
resp = self.client.post(url)
code = 200
self.assertEqual(resp.status_code, code,
"got code {0} for url '{1}'. Expected code {2}"
.format(resp.status_code, url, code))
class TestElasticstack(TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_form_kwargs(self):
"""Ensure request data updates the form kwargs"""
request = self.factory.request()
request.GET = {"q": "whoami"}
mixin = views.SearchMixin()
mixin.request = request
mixin.queryset = [] # An EmptySearchQuerySet is basically an empty list
self.assertEqual(
mixin.get_form_kwargs(),
{"initial": {}, "data": request.GET, "searchqueryset": []},
)
def test_log_encrypted_cookies(self, mock_encrypt,
mock_capture_cookie_sizes):
middleware = CookieMonitoringMiddleware()
cookies_dict = {
"a": "." * 10,
"b": "." * 15,
}
factory = RequestFactory()
for name, value in cookies_dict.items():
factory.cookies[name] = value
mock_request = factory.request()
cookie_header = str(mock_request.META.get('HTTP_COOKIE', ''))
middleware.process_request(mock_request)
mock_encrypt.assert_has_calls([call(cookie_header, "fake-key")])
def testBeginLogin(self):
# skip the test if openid is not enabled (as in cms.envs.test):
if not settings.MITX_FEATURES.get('AUTH_USE_OPENID') or not settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'):
return
# the provider URL must be converted to an absolute URL in order to be
# used as an openid provider.
provider_url = reverse('openid-provider-xrds')
factory = RequestFactory()
request = factory.request()
abs_provider_url = request.build_absolute_uri(location=provider_url)
# now we can begin the login process by invoking a local openid client,
# with a pointer to the (also-local) openid provider:
with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url):
url = reverse('openid-login')
resp = self.client.post(url)
code = 200
self.assertEqual(resp.status_code, code,
"got code {0} for url '{1}'. Expected code {2}"
.format(resp.status_code, url, code))
def _send_bad_redirection_login(self):
"""
Attempt to log in to the provider with setup parameters
Intentionally fail the login to force a redirect
"""
user = UserFactory()
factory = RequestFactory()
post_params = {'email': user.email, 'password': '******'}
fake_url = 'fake url'
request = factory.post(reverse('openid-provider-login'), post_params)
openid_setup = {
'request': factory.request(),
'url': fake_url
}
request.session = {
'openid_setup': openid_setup
}
response = provider_login(request)
return response
def test_safe_get_host(self):
""" Tests that the safe_get_host function returns the desired host """
settings.SITE_NAME = 'siteName.com'
factory = RequestFactory()
request = factory.request()
request.META['HTTP_HOST'] = 'www.userProvidedHost.com'
# If ALLOWED_HOSTS is not set properly, safe_get_host should return SITE_NAME
settings.ALLOWED_HOSTS = None
self.assertEqual(safe_get_host(request), "siteName.com")
settings.ALLOWED_HOSTS = ["*"]
self.assertEqual(safe_get_host(request), "siteName.com")
settings.ALLOWED_HOSTS = ["foo.com", "*"]
self.assertEqual(safe_get_host(request), "siteName.com")
# If ALLOWED_HOSTS is set properly, and the host is valid, we just return the user-provided host
settings.ALLOWED_HOSTS = [request.META['HTTP_HOST']]
self.assertEqual(safe_get_host(request), request.META['HTTP_HOST'])
# If ALLOWED_HOSTS is set properly but the host is invalid, we should get a SuspiciousOperation
settings.ALLOWED_HOSTS = ["the_valid_website.com"]
with self.assertRaises(SuspiciousOperation):
safe_get_host(request)
def test_context_processor(self):
f = RequestFactory()
c = RequestContext(f.request())
self.assertTrue(c.get('settings') is settings)
def request(self, path, action, data=None):
"""
Make an internal API request.
"""
# Make sure an API user and token are defined
if not self.api_user or not self.api_token:
return self.log.error('Failed to make API request, API user and/or token not set')
# Define the full endpoint
endpoint = '%s/%s' % (path, action)
# If data is supplied, make sure it is valid
if data and not isinstance(data, dict):
return self.log.error('Failed to make API request, request data must be in dictionary format')
# Make sure the endpoint is valid
if not endpoint in self.endpoints:
return self.log.error('Failed to make API request, endpoint not found: %s/%s' % (path, action))
# Log the request details
self.log.info('Submitting API request: endpoint=%s, api_user=%s, data=%s' % (endpoint, self.api_user, ('None' if not data else json.dumps(data))))
# Attempt to construct a new request object
try:
# Define the request defaults
defaults = {
'REQUEST_METHOD': self.endpoints[endpoint]['method'],
'SERVER_NAME': self.conf.server.host,
'PATH_INFO': '/%s' % path,
'REQUEST_URI': '/cloudscape-api/%s' % path,
'SCRIPT_NAME': '/cloudscape-api',
'SERVER_PORT': '10550',
'CONTENT_TYPE': 'application/json'
}
# Create a new instance of the request factory
rf = RequestFactory(**defaults)
# Construct the request object
request_obj = rf.request()
# Define the request body
body = {
'api_user': self.api_user,
'api_token': self.api_token,
'api_group': self.api_group,
'action': action
}
# If any request data
if data:
body['_data'] = data
# Set the request body
request_obj._body = json.dumps(body)
# Critical error when constructing request object
except Exception as e:
self.log.exception('Failed to construct request object: %s' % str(e))
# Dispatch the request and get the response
response = parse_response(request.dispatch(request_obj))
# Load the response body
def load_body(body):
try:
return json.loads(body)
except:
return body
# Return the response
return {
'code': response['code'],
'body': load_body(response['body'])
}
def testGetSubdomainMiddleware1(self):
"Test GetSubdomainMiddleware.process_request succeds without exceptions on a request."
rf = RequestFactory(subdomain = 'foo')
request = rf.request()
middleware = GetSubdomainMiddleware()
middleware.process_request(request)
