def testResubmitProposal(self):
"""Tests that a proposal is successfully resubmitted if possible."""
old_number_of_proposals = self.profile.student_data.number_of_proposals
self.kwargs = {
'sponsor': self.sponsor.link_id,
'program': self.program.program_id,
'user': self.profile.profile_id,
'id': self.proposal.key().id()
}
request = http.HttpRequest()
data = request_data.RequestData(request, None, self.kwargs)
handler = proposal_review_view.ResubmitProposalHandler(None)
with mock.patch.object(proposal_logic,
'canProposalBeResubmitted',
return_value=True):
response = handler.handle(data, None, None)
self.assertEqual(response.status_code, httplib.OK)
# check that the proposal is withdrawn
proposal = GSoCProposal.all().get()
self.assertEqual(proposal.status, proposal_model.STATUS_PENDING)
# check that number of proposals is updated
profile = self.profile.key.get()
self.assertEqual(old_number_of_proposals,
profile.student_data.number_of_proposals - 1)
def test_get_allowed_origin_is_string(self):
middleware = self.load_middleware()
request = http.HttpRequest()
allowed_origin = middleware._get_allowed_origin(request)
self.assertEqual(allowed_origin, 'localhost:8080')
def testEmailIsSent(self):
"""Tests that acceptance and rejection emails are sent."""
# seed a couple of organization administrators for both organizations
addresses_for_accept_email = []
addresses_for_reject_email = []
for _ in range(_NUMBER_OF_ORG_ADMINS):
profile = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.pre_accepted_org.key])
addresses_for_accept_email.append(profile.contact.email)
profile = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.pre_rejected_org.key])
addresses_for_reject_email.append(profile.contact.email)
# finalize decision and execute all MapReduce jobs
kwargs = {
'sponsor': self.sponsor.key().name(),
'program': self.program.program_id,
}
request = http.HttpRequest()
data = request_data.RequestData(request, None, kwargs)
handler = org_app_view.ApplyOrgAdmissionDecisionHandler(_MockView())
handler.handle(data, None, None)
self.executeMapReduceJobs()
# check that emails have been sent
for email_address in addresses_for_accept_email:
self.assertEmailSent(bcc=email_address)
for email_address in addresses_for_reject_email:
self.assertEmailSent(bcc=email_address)
def test_response_without_messages(self):
"""
MessageMiddleware is tolerant of messages not existing on request.
"""
request = http.HttpRequest()
response = http.HttpResponse()
self.middleware.process_response(request, response)
def test_update_user_pin_unlock(self, client):
email = '*****@*****.**'
req = http.HttpRequest()
req.session = {'last_pin_success': datetime.now()}
user = get_uuid(email)
eq_(set_user(req, email), user)
assert req.session['last_pin_success'] is None
def default_prefixer(sender, **kwargs):
"""Make sure each test starts with a default URL prefixer."""
request = http.HttpRequest()
request.META['SCRIPT_NAME'] = ''
prefixer = urlresolvers.Prefixer(request)
prefixer.locale = settings.LANGUAGE_CODE
urlresolvers.set_url_prefix(prefixer)
def as_request(self):
assert self.request_data, 'Could not construct an empty TestCase object'
request = http.HttpRequest()
data = self.request_data_dict
request.path = data['path']
request.method = data['method']
request.path_info = data['path_info']
request._body = data['body']
request.META = data['headers']
request._encoding = data['encoding']
request._stream = StringIO()
request._read_started = False
request._post_parse_error = False
request.resolver_match = None
request._load_post_and_files()
query_string = '%s&%s=1' % (data['query_string'], TEST_REQUEST_PARAM)
request.GET = http.QueryDict(query_string, encoding=request.encoding)
request.POST = getattr(request, '_post')
request.FILES = getattr(request, '_files')
request.COOKIES = http.parse_cookie(
request.META.get('HTTP_COOKIE', b''))
request.REQUEST = datastructures.MergeDict(request.POST, request.GET)
# extra attributes added by middlewares
from django.contrib.auth.middleware import get_user
engine = import_module(settings.SESSION_ENGINE)
request.session = engine.SessionStore(
request.COOKIES.get(settings.SESSION_COOKIE_NAME, None))
request.user = SimpleLazyObject(lambda: get_user(request))
return request
def test_timezone(self):
import datetime
http_request = http.HttpRequest()
self.executed = False
td = datetime.timedelta(hours=-5)
now = datetime.datetime.utcnow()
def echo(d):
self.assertEqual(d, now + td)
self.executed = True
return d
gw = django.DjangoGateway({'test.test': echo},
timezone_offset=-18000,
expose_request=False)
msg = remoting.Envelope(amfVersion=pyamf.AMF0)
msg['/1'] = remoting.Request(target='test.test', body=[now])
http_request.method = 'POST'
http_request.raw_post_data = remoting.encode(msg).getvalue()
res = remoting.decode(gw(http_request).content)
self.assertTrue(self.executed)
self.assertEqual(res['/1'].body, now)
def clean_content(self):
content = self.cleaned_data['content']
if not content and self.cleaned_data['is_custom']:
template_name = self.cleaned_data['template_name']
for template_loader in loader.template_source_loaders:
try:
content = template_loader.load_template_source(
template_name)[0]
break
except Exception:
continue
if django_version() >= '1.5':
from django.test.client import RequestFactory
request = RequestFactory().get('/')
else:
request = http.HttpRequest()
request.session = {}
context = template.RequestContext(request, {
'page_slug': self.instance.title,
'page': self.instance
})
if content:
try:
template.Template(content).render(context)
except Exception:
import traceback
traceback.print_exc()
raise forms.ValidationError(_("Template error detected"))
return content
def test_really_bad_decode(self):
self.old_method = remoting.decode
remoting.decode = lambda *args, **kwargs: self._raiseException(
Exception, *args, **kwargs)
http_request = http.HttpRequest()
http_request.method = 'POST'
http_request.raw_post_data = ''
gw = django.DjangoGateway()
try:
http_response = gw(http_request)
except:
remoting.decode = self.old_method
raise
remoting.decode = self.old_method
self.assertTrue(isinstance(http_response,
http.HttpResponseServerError))
self.assertEqual(http_response.status_code, 500)
self.assertEqual(
http_response.content,
'500 Internal Server Error\n\nAn unexpected error occurred.')
def test_get(self):
storage = UserMessagesStorage(http.HttpRequest())
storage.request.user = self.user
self.user.message_set.create(message='test message')
self.assertEqual(len(storage), 1)
self.assertEqual(list(storage)[0].message, 'test message')
def testOrganizationStatusIsUpdated(self):
"""Tests that organization admission decisions are applied correctly."""
kwargs = {
'sponsor': self.sponsor.key().name(),
'program': self.program.program_id,
}
request = http.HttpRequest()
data = request_data.RequestData(request, None, kwargs)
handler = org_app_view.ApplyOrgAdmissionDecisionHandler(_MockView())
handler.handle(data, None, None)
self.executeMapReduceJobs()
# check that status have been changed for pre_accepted and pre_rejected orgs
self.assertEqual(
self.pre_accepted_org.key.get().status, org_model.Status.ACCEPTED)
self.assertEqual(
self.pre_rejected_org.key.get().status, org_model.Status.REJECTED)
# check that status for other orgs have not changed
self.assertEqual(
self.accepted_org.key.get().status, org_model.Status.ACCEPTED)
self.assertEqual(
self.rejected_org.key.get().status, org_model.Status.REJECTED)
self.assertEqual(
self.applying_org.key.get().status, org_model.Status.APPLYING)
def setUp(self):
self.mox = mox.Mox()
self.factory = RequestFactoryWithMessages()
def fake_conn_request(*args, **kwargs):
raise Exception("An external URI request tried to escape through "
"an httplib2 client. Args: %s, kwargs: %s" %
(args, kwargs))
self._real_conn_request = httplib2.Http._conn_request
httplib2.Http._conn_request = fake_conn_request
self._real_horizon_context_processor = context_processors.horizon
context_processors.horizon = lambda request: self.TEST_CONTEXT
self._real_get_user_from_request = users.get_user_from_request
tenants = self.TEST_CONTEXT['authorized_tenants']
self.setActiveUser(token=self.TEST_TOKEN,
username=self.TEST_USER,
tenant_id=self.TEST_TENANT,
service_catalog=self.TEST_SERVICE_CATALOG,
authorized_tenants=tenants)
self.request = http.HttpRequest()
self.request.session = self.client._session()
middleware.HorizonMiddleware().process_request(self.request)
def setUp(self):
self.request = http.HttpRequest()
self.request.session = {
'uuid': 'some uuid',
'uuid_has_pin': True,
'uuid_has_confirmed_pin': True
}
def setUp(self):
mock_user = user.User(id=1, roles=self._roles)
patcher = mock.patch('openstack_auth.utils.get_user',
return_value=mock_user)
self.MockClass = patcher.start()
self.addCleanup(patcher.stop)
self.request = http.HttpRequest()
def setUp(self):
load_test_data(self)
self.mox = mox.Mox()
self.factory = RequestFactoryWithMessages()
self.context = {'authorized_tenants': self.tenants.list()}
def fake_conn_request(*args, **kwargs):
raise Exception("An external URI request tried to escape through "
"an httplib2 client. Args: %s, kwargs: %s" %
(args, kwargs))
self._real_conn_request = httplib2.Http._conn_request
httplib2.Http._conn_request = fake_conn_request
self._real_horizon_context_processor = context_processors.horizon
context_processors.horizon = lambda request: self.context
self._real_get_user = utils.get_user
tenants = self.context['authorized_tenants']
self.setActiveUser(id=self.user.id,
token=self.token,
username=self.user.name,
tenant_id=self.tenant.id,
service_catalog=self.service_catalog,
authorized_tenants=tenants)
self.request = http.HttpRequest()
self.request.session = self.client._session()
self.request.session['token'] = self.token.id
middleware.HorizonMiddleware().process_request(self.request)
AuthenticationMiddleware().process_request(self.request)
os.environ["HORIZON_TEST_RUN"] = "True"
def test_get_current_user(self):
# Set up a test user.
email = '*****@*****.**'
user = User(email=email)
user.save()
# Create some security tokens.
expired_token = auth._create_security_token(user)
self.now += 0.75 * auth._TOKEN_TIMEOUT_S
stale_token = auth._create_security_token(user)
self.now += 0.75 * auth._TOKEN_TIMEOUT_S
good_token = auth._create_security_token(user)
# Create a test HttpRequest, and test using it against our
# various tokens.
request = http.HttpRequest()
request.COOKIES[auth._CHIRP_SECURITY_TOKEN_COOKIE] = expired_token
self.assertEqual(None, auth.get_current_user(request))
request.COOKIES[auth._CHIRP_SECURITY_TOKEN_COOKIE] = stale_token
user = auth.get_current_user(request)
self.assertEqual(email, user.email)
self.assertTrue(user._credentials.security_token_is_stale)
request.COOKIES[auth._CHIRP_SECURITY_TOKEN_COOKIE] = good_token
user = auth.get_current_user(request)
self.assertEqual(email, user.email)
self.assertFalse(user._credentials.security_token_is_stale)
# Test that a password reset token can be used to authenticate
# when POSTed in a variable named CHIRP_Auth.
request = http.HttpRequest()
request.method = "POST"
self.assertEqual(None, auth.get_current_user(request))
request.POST["CHIRP_Auth"] = base64.urlsafe_b64encode(expired_token)
self.assertEqual(None, auth.get_current_user(request))
request.POST["CHIRP_Auth"] = "bogus!!!"
self.assertEqual(None, auth.get_current_user(request))
request.POST["CHIRP_Auth"] = base64.urlsafe_b64encode(good_token)
user = auth.get_current_user(request)
self.assertEqual(email, user.email)
# Check that we will reject an inactive user.
user.is_active = False
user.save()
self.assertRaises(auth.UserNotAllowedError, auth.get_current_user,
request)
user.is_active = True
user.save()
def setUp(self):
self.mox = mox.Mox()
self._real_get_user_from_request = keystone.get_user_from_request
self.setActiveUser(self.TEST_TOKEN, self.TEST_USER, self.TEST_TENANT,
True, self.TEST_SERVICE_CATALOG)
self.request = http.HttpRequest()
keystone.AuthenticationMiddleware().process_request(self.request)
def test_get_allowed_origin_is_list(self):
middleware = self.load_middleware()
request = http.HttpRequest()
request.META['HTTP_ORIGIN'] = 'localhost:9090'
allowed_origin = middleware._get_allowed_origin(request)
self.assertEqual(allowed_origin, 'localhost:9090')
def test_process_request(self):
pre_handler = CookiePreHandlerMiddleware()
request = http.HttpRequest()
request.COOKIES['cookie1'] = 'cookie_value1'
pre_handler.process_request(request)
self.assertEquals('cookie_value1', request.COOKIES.get('cookie1'))
def default_prefixer():
"""Make sure each test starts with a default URL prefixer."""
request = http.HttpRequest()
request.META['SCRIPT_NAME'] = ''
prefixer = amo.urlresolvers.Prefixer(request)
prefixer.app = settings.DEFAULT_APP
prefixer.locale = settings.LANGUAGE_CODE
amo.urlresolvers.set_url_prefix(prefixer)
def test_request_method(self):
gw = django.DjangoGateway()
http_request = http.HttpRequest()
http_request.method = 'GET'
http_response = gw(http_request)
self.assertEqual(http_response.status_code, 405)
def test_get_allowed_origin_lambda_return_false(self):
middleware = self.load_middleware()
request = http.HttpRequest()
request.META['HTTP_ORIGIN'] = 'localhost:9999'
allowed_origin = middleware._get_allowed_origin(request)
self.assertEqual(allowed_origin, '')
def test_process_template_response_with_error(self):
"""
The middleware should NOT process error responses.
"""
response = http.HttpResponseServerError()
request = http.HttpRequest()
response = self.middleware.process_template_response(request, response)
self.assertFalse(hasattr(response, 'context_data'))
def test_simple(django_assert_num_queries):
reporter1 = models.Reporter.objects.create(
first_name='reporter1',
)
reporter2 = models.Reporter.objects.create(
first_name='reporter2',
)
class Reporter(gdtools.Resolver):
schema = {
'type': {'first_name': 'String!'},
}
model = models.Reporter
class GetReporter(gdtools.Resolver):
schema = {
'args': {
'id': 'ID'
},
'type': 'Reporter'
}
def resolve(self, **kwargs):
return self.resolve_gid(kwargs['id'])
class Query(graphene.ObjectType):
get_reporter = GetReporter.as_field()
schema = graphene.Schema(
query=Query,
)
with django_assert_num_queries(1):
result = schema.execute(
'''\
query getReporters($id1: ID, $id2: ID){
reporter1: getReporter(id: $id1) {
firstName
}
reporter2: getReporter(id: $id2) {
firstName
}
}
''',
context=http.HttpRequest(),
variables={
'id1': gdtools.GlobalID.from_object(reporter1),
'id2': gdtools.GlobalID.from_object(reporter2),
}
)
assert not result.errors
assert result.data == {
'reporter1': {
'firstName': 'reporter1'
},
'reporter2': {
'firstName': 'reporter2'
}
}
def test_create_new_user_has_permission(self):
http_request = http.HttpRequest()
http_request.method = api_util.HTTPMethod.POST.name
rest_request = request.Request(http_request)
expected_permission = self.user_permissions.has_permission(
request=rest_request)
self.assertTrue(expected_permission)
def test_get_user_fails_no_authentication(self):
http_request = http.HttpRequest()
http_request.method = api_util.HTTPMethod.GET
rest_request = request.Request(http_request)
expected_permission = self.user_permissions.has_permission(
request=rest_request)
self.assertFalse(expected_permission)
def testInitializer(self):
"""Tests that per-request objects are created."""
request = http.HttpRequest()
data, check, mutator = initialize.MELANGE_INITIALIZER.initialize(
request, [], {})
self.assertEqual(request, data.request)
self.assertEqual(data, check.data)
self.assertEqual(data, mutator.data)
def test_response_without_notifications(self):
"""
A higher middleware layer may return a request directly before
notifications get applied, so the response middleware is tolerant of
notifications not existing on request.
"""
request = http.HttpRequest()
response = http.HttpResponse()
self.middleware.process_response(request, response)
def test_search_no_permission(self):
http_request = http.HttpRequest()
http_request.method = api_util.HTTPMethod.POST.name
rest_request = request.Request(http_request)
expected_permission = self.search_permission.has_permission(
request=rest_request)
self.assertFalse(expected_permission)
