def test_form_valid(self, user: User, rf: RequestFactory):
view = UserUpdateView()
request = rf.get("/fake-url/")
# Add the session/message middleware to the request
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
request.user = user
view.request = request
# Initialize the form
form = UserChangeForm()
form.cleaned_data = []
view.form_valid(form)
messages_sent = [m.message for m in messages.get_messages(request)]
assert messages_sent == ["Information successfully updated"]
def setUp(self):
self.request = HttpRequest()
# self.request.user = AnonymousUser()
self.request.user = None
data = {
'email': '*****@*****.**',
'password': '******',
'password2': 'aloc666123',
}
self.request.method = 'POST'
self.request.POST = data
middleware = SessionMiddleware()
middleware.process_request(self.request)
self.request.session.save()
middleware = MessageMiddleware()
middleware.process_request(self.request)
self.request.session.save()
self.request.META['HTTP_HOST'] = '127.0.0.1'
def test_admin_post_text(self):
page1, page2 = self.get_pages()
post = self._get_post(self.data['en'][0])
with self.settings(BLOG_USE_PLACEHOLDER=False):
data = {'post_text': 'ehi text'}
request = self.post_request(page1,
'en',
data=data,
path='/en/?edit_fields=post_text')
msg_mid = MessageMiddleware()
msg_mid.process_request(request)
post_admin = admin.site._registry[Post]
post_admin.edit_field(request, post.pk, 'en')
modified_post = Post.objects.get(pk=post.pk)
self.assertEqual(
modified_post.safe_translation_getter('post_text'),
data['post_text'])
def setUp(self):
super(AccountSettingsViewTest, self).setUp()
self.user = UserFactory.create(username=self.USERNAME, password=self.PASSWORD)
CommerceConfiguration.objects.create(cache_ttl=10, enabled=True)
self.client.login(username=self.USERNAME, password=self.PASSWORD)
self.request = HttpRequest()
self.request.user = self.user
# For these tests, two third party auth providers are enabled by default:
self.configure_google_provider(enabled=True, visible=True)
self.configure_facebook_provider(enabled=True, visible=True)
# Python-social saves auth failure notifcations in Django messages.
# See pipeline.get_duplicate_provider() for details.
self.request.COOKIES = {}
MessageMiddleware().process_request(self.request)
messages.error(self.request, 'Facebook is already in use.', extra_tags='Auth facebook')
def test_signup_email_twice(self):
request = RequestFactory().post(
reverse('account_signup'), {
'username': '******',
'email': '*****@*****.**',
'email2': '*****@*****.**',
'password1': 'johndoe',
'password2': 'johndoe'
})
from django.contrib.messages.middleware import MessageMiddleware
from django.contrib.sessions.middleware import SessionMiddleware
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
request.user = AnonymousUser()
from .views import signup
signup(request)
user = get_user_model().objects.get(username='******')
self.assertEqual(user.email, '*****@*****.**')
def test_profile_post_invalid(self):
path = reverse('profile')
request = self.factory.post(path,
data={
'username': '******',
'email': 'paulocamargoss_outlook.com',
'image': '',
})
request.user = mixer.blend(User)
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
middleware = MessageMiddleware()
middleware.process_request(request)
request.session.save()
response = profile(request)
assert response.status_code == 200
def test__resync_instances_stripe_invalid_request_error(self, monkeypatch):
model = TestCustomActionModel
# create instance to be used in the Django Admin Action
instance = model.objects.create(id="test")
data = {
"action": "_resync_instances",
helpers.ACTION_CHECKBOX_NAME: [instance.pk],
}
# monkeypatch instance.api_retrieve and app_config.get_model
def mock_instance_api_retrieve(*args, **kwargs):
raise stripe.error.InvalidRequestError({}, "some random error message")
def mock_get_model(*args, **kwargs):
return model
monkeypatch.setattr(instance, "api_retrieve", mock_instance_api_retrieve)
monkeypatch.setattr(utils, "get_model", mock_get_model)
kwargs = {
"action_name": "_resync_instances",
"model_name": model.__name__.lower(),
}
# get the custom action POST url
change_url = reverse("djstripe:djstripe_custom_action", kwargs=kwargs)
request = RequestFactory().post(change_url, data=data, follow=True)
# Add the session/message middleware to the request
SessionMiddleware(self.dummy_get_response).process_request(request)
MessageMiddleware(self.dummy_get_response).process_request(request)
view = ConfirmCustomAction()
view.setup(request, **kwargs)
with pytest.raises(stripe.error.InvalidRequestError) as exc_info:
# Invoke the Custom Actions
view._resync_instances(request, [instance])
assert str(exc_info.value.param) == "some random error message"
def test_populate_username_in_blacklist(self):
factory = RequestFactory()
request = factory.get('/accounts/twitter/login/callback/')
request.user = AnonymousUser()
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
User = get_user_model()
user = User()
setattr(user, account_settings.USER_MODEL_USERNAME_FIELD, 'username')
setattr(user, account_settings.USER_MODEL_EMAIL_FIELD,
'*****@*****.**')
account = SocialAccount(provider='twitter', uid='123')
sociallogin = SocialLogin(user=user, account=account)
complete_social_login(request, sociallogin)
self.assertNotIn(request.user.username,
account_settings.USERNAME_BLACKLIST)
def setUp(self):
noon = datetime.datetime.combine(datetime.date.today(),
datetime.time(12, 0))
self.factory = RequestFactory()
self.sessions = SessionMiddleware()
self.messages = MessageMiddleware()
self.event1 = models.Event.objects.create(datetime=noon,
targetamount=5)
self.run1 = models.SpeedRun.objects.create(name='Test Run 1',
run_time='0:45:00',
setup_time='0:05:00',
order=1)
self.run2 = models.SpeedRun.objects.create(name='Test Run 2',
run_time='0:15:00',
setup_time='0:05:00',
order=2)
if not User.objects.filter(username='******').exists():
User.objects.create_superuser('admin', '*****@*****.**',
'password')
def test_can_capture_a_metric_when_a_submission_is_created(
self, mock_write_points, mock_list_db, mock_create_db):
# Setup
mock_write_points.side_effect = fake_write_points
post_data = {
'journal': self.journal.pk,
'year': '2015',
'volume': '2',
'number': '2',
'contact': self.user.pk,
'comment': 'lorem ipsum dolor sit amet',
}
request = self.factory.post(
reverse('userspace:journal:editor:add', args=(self.journal.pk, )),
post_data)
request.user = self.user
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
MessageMiddleware().process_request(request)
view = IssueSubmissionCreate(request=request,
journal_pk=self.journal.pk)
view.current_journal = self.journal
# Run
view.post(request)
# Check
global _test_points
self.assertEqual(len(_test_points), 1)
issuesubmission = IssueSubmission.objects.last()
self.assertEqual(_test_points,
[{
'tags': {},
'fields': {
'author_id': self.user.pk,
'submission_id': issuesubmission.pk,
'num': 1,
},
'measurement': 'erudit__issuesubmission__create',
}])
def test_email_address_created(self):
factory = RequestFactory()
request = factory.get('/accounts/login/callback/')
request.user = AnonymousUser()
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
User = get_user_model()
user = User()
setattr(user, account_settings.USER_MODEL_USERNAME_FIELD, 'test')
setattr(user, account_settings.USER_MODEL_EMAIL_FIELD, "*****@*****.**")
account = SocialAccount(provider='openid', uid='123')
sociallogin = SocialLogin(user=user, account=account)
complete_social_login(request, sociallogin)
user = User.objects.get(**{account_settings.USER_MODEL_USERNAME_FIELD: 'test'})
self.assertTrue(SocialAccount.objects.filter(user=user, uid=account.uid).exists())
self.assertTrue(EmailAddress.objects.filter(user=user, email=user_email(user)).exists())
def test_matching_in_transaction(self):
"""This is a regression test.
In case of automatic person data rewrite, when matching a Training
Request with Person, uniqueness constraint can be broken. In such
scenario AMY must inform correctly about the issue, not throw 500
error."""
# this email conflicts with `duplicate` person below
tr = create_training_request(state='p', person=None)
tr.personal = 'John'
tr.family = 'Smith'
tr.email = '*****@*****.**'
tr.save()
# a fake request
factory = RequestFactory()
request = factory.get("/") # doesn't really matter where
# adding session middleware, because it's required by messages
session_middleware = SessionMiddleware()
session_middleware.process_request(request)
request.session.save()
# adding messages because they're used in
# _match_training_request_to_person
messages_middleware = MessageMiddleware()
messages_middleware.process_request(request)
create = False
person = Person.objects.create(username='******',
personal='john',
family='smith',
email='*****@*****.**')
duplicate = Person.objects.create(username='******',
personal='jonny',
family='smith',
email='*****@*****.**')
# matching fails because it can't rewrite email address due to
# uniqueness constraint
self.assertFalse(
_match_training_request_to_person(request, tr, create, person))
messages = request._messages._queued_messages
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].level, WARNING)
def test_signup_email_verified_externally(self):
request = RequestFactory().post(
reverse('account_signup'), {
'username': '******',
'email': '*****@*****.**',
'password1': 'johndoe',
'password2': 'johndoe'
})
# Fake stash_email_verified
from django.contrib.messages.middleware import MessageMiddleware
from django.contrib.sessions.middleware import SessionMiddleware
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
request.session['account_email_verified'] = '*****@*****.**'
from views import signup
resp = signup(request)
self.assertEquals(resp.status_code, 302)
self.assertEquals(resp['location'], settings.LOGIN_REDIRECT_URL)
self.assertEquals(len(mail.outbox), 0)
def test_datagroup_create_dupe_filename(self):
csv_string = (
"filename,title,document_type,url,organization\n"
"0bf5755e-3a08-4024-9d2f-0ea155a9bd17.pdf,NUTRA NAIL,MS,, \n"
"0bf5755e-3a08-4024-9d2f-0ea155a9bd17.pdf,Body Cream,MS,, \n")
data = io.StringIO(csv_string)
sample_csv = InMemoryUploadedFile(
data,
field_name="csv",
name="register_records.csv",
content_type="text/csv",
size=len(csv_string),
charset="utf-8",
)
form_data = {
"name": ["Walmart MSDS Test Group"],
"description": ["test data group"],
"group_type": ["2"],
"downloaded_by": [str(User.objects.get(username="******").pk)],
"downloaded_at": ["08/02/2018"],
"download_script": ["1"],
"data_source": ["10"],
}
request = self.factory.post(path="/datagroup/new/", data=form_data)
request.FILES["csv"] = sample_csv
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
middleware = MessageMiddleware()
middleware.process_request(request)
request.session.save()
request.user = User.objects.get(username="******")
request.session = {}
request.session["datasource_title"] = "Walmart"
request.session["datasource_pk"] = 10
resp = views.data_group_create(request=request, pk=10)
self.assertContains(
resp,
"Duplicate "filename" values for ""
"0bf5755e-3a08-4024-9d2f-0ea155a9bd17.pdf" are not allowed.",
)
def setUp(self):
User = get_user_model()
# Thanks to https://github.com/Sammcb/TEMPS/tree/master/pages for helping me test http requests
# As well as helping with signing in with google
factory = RequestFactory()
self.request = factory.get('/google/login/callback/')
self.request.user = AnonymousUser()
SessionMiddleware().process_request(self.request)
MessageMiddleware().process_request(self.request)
user = User(username='******', email='*****@*****.**')
account = SocialAccount(user=user, provider='Gmail', uid='123')
sociallogin = SocialLogin(user=user, account=account)
complete_social_login(self.request, sociallogin)
self.assertTrue(self.request.user.is_authenticated)
# The creation of Sherriff
Sherriff = User.objects.create_user(username="******",
first_name="Mark",
last_name="Sherriff",
email="*****@*****.**")
Sherriff.set_password("sherriff's password")
Sherriff_profile = Profile.objects.get(user=Sherriff)
Sherriff_profile.phone = "434-982-2688"
Sherriff_profile.save()
Sherriff_tutor = Tutor.objects.get(profile=Sherriff_profile)
Sherriff_tutor.courses.add(Course.objects.get(name="CS 3240"))
Sherriff_student = Student.objects.get(profile=Sherriff_profile)
Sherriff_student.courses.add(Course.objects.get(name="CS 2150"))
# The creation of Bloomfield
Bloomfield = User.objects.get(username="******")
Bloomfield_profile = Profile.objects.get(user=Bloomfield)
Bloomfield_profile.phone = "434-982-2215"
Bloomfield_profile.save()
Bloomfield_tutor = Tutor.objects.get(profile=Profile.objects.get(
user=Bloomfield))
Bloomfield_tutor.courses.add(Course.objects.get(name="CS 2150"))
Bloomfield_student = Student.objects.get(profile=Profile.objects.get(
user=Bloomfield))
Bloomfield_student.courses.add(Course.objects.get(name="CS 3240"))
def test_add_student_view(self):
create_url = reverse("add-student")
# instructor is an admin case:
request = self.factory.post(create_url, self.student_data_1)
request.user = self.instructor1.user
"""When you use RequestFactory only the view runs,
not the middleware. That why we need first to annotate
it with a session and then a messages. """
# Annotate a request object with a session
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
# Annotate a request object with a messages
middleware = MessageMiddleware()
middleware.process_request(request)
request.session.save()
response = views.add_student(request)
self.assertEqual(response.status_code, 200)
def test_replace_text_preserves_whitespace(self):
request = RequestFactory().post(
"/",
{
"search": " the ",
"replace": "X ",
"search_and_replace_cat_bio": "true",
"apply": "true",
"preview_id": "more-ids-used-to-prevent-double-submit",
},
)
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
SearchAndReplaceView.as_view(
models_and_fields=self.models_and_fields)(request)
self.lucy.refresh_from_db()
self.assertEqual(self.lucy.bio, "Grew up inX deep south.")
def get_request(user: AbstractBaseUser = None):
"""
Creates and returns a django request.
"""
# Create test request
factory = RequestFactory()
request = factory.get('/')
request.user = user
# Annotate a request object with a session
session_middleware = SessionMiddleware()
session_middleware.process_request(request)
request.session.save()
# Annotate a request object with messages
message_middleware = MessageMiddleware()
message_middleware.process_request(request)
request.session.save()
return request
def test_register_post_valid(self):
path = reverse('register')
request = self.factory.post(path,
data={
'username': '******',
'email': '*****@*****.**',
'password1': 'hackmehackme',
'password2': 'hackmehackme',
})
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
middleware = MessageMiddleware()
middleware.process_request(request)
request.session.save()
response = register(request)
assert response.status_code == 302
assert reverse('login') in response.url
def test_http_exception_redirection(self):
"""
Test ExceptionMiddleware is correctly redirected to login page
when PSA raises HttpError exception.
"""
request = RequestFactory().get("dummy_url")
next_url = get_next_url_for_login_page(request)
login_url = '/login?next=' + next_url
request.META['HTTP_REFERER'] = 'http://example.com:8000/login'
exception = HTTPError()
exception.response = HttpResponse(status=502)
# Add error message for error in auth pipeline
MessageMiddleware().process_request(request)
response = ExceptionMiddleware().process_exception(request, exception)
target_url = response.url
self.assertEqual(response.status_code, 302)
self.assertTrue(target_url.endswith(login_url))
def setUp(self):
self.factory = RequestFactory()
self.sessions = SessionMiddleware()
self.messages = MessageMiddleware()
self.event1 = models.Event.objects.create(
datetime=today_noon,
targetamount=5,
timezone=pytz.timezone(
getattr(settings, 'TIME_ZONE', 'America/Denver')),
)
self.run1 = models.SpeedRun.objects.create(name='Test Run 1',
run_time='0:45:00',
setup_time='0:05:00',
order=1)
self.run2 = models.SpeedRun.objects.create(name='Test Run 2',
run_time='0:15:00',
setup_time='0:05:00',
order=2)
if not User.objects.filter(username='******').exists():
User.objects.create_superuser('admin', '*****@*****.**',
'password')
def test_admin_post_text(self):
pages = self.get_pages()
post = self._get_post(self._post_data[0]['en'])
with self.login_user_context(self.user):
with self.settings(BLOG_USE_PLACEHOLDER=False):
data = {'post_text': 'ehi text', 'title': 'some title'}
request = self.post_request(pages[0],
'en',
user=self.user,
data=data,
path='/en/?edit_fields=post_text')
msg_mid = MessageMiddleware()
msg_mid.process_request(request)
post_admin = admin.site._registry[Post]
response = post_admin.edit_field(request, post.pk, 'en')
self.assertEqual(response.status_code, 200)
modified_post = Post.objects.language('en').get(pk=post.pk)
self.assertEqual(
modified_post.safe_translation_getter('post_text'),
data['post_text'])
def _test_signup_email_verified_externally(self, signup_email, verified_email):
username = '******'
request = RequestFactory().post(reverse('account_signup'),
{ 'username': username,
'email': signup_email,
'password1': 'johndoe',
'password2': 'johndoe' })
# Fake stash_verified_email
from django.contrib.messages.middleware import MessageMiddleware
from django.contrib.sessions.middleware import SessionMiddleware
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
request.user = AnonymousUser()
request.session['account_verified_email'] = verified_email
from .views import signup
resp = signup(request)
self.assertEqual(resp.status_code, 302)
self.assertEqual(resp['location'],
get_adapter().get_login_redirect_url(request))
self.assertEqual(len(mail.outbox), 0)
return User.objects.get(username=username)
def setUp(self):
self.factory = RequestFactory()
self.organization = OrganizationFactory()
self.owner = PersonFactory()
self.owner_member = OrganizationMember.objects.create(
organization=self.organization,
person=self.owner,
role=OrganizationMember.OWNER,
)
self.editor = PersonFactory()
self.editor_member = OrganizationMember.objects.create(
organization=self.organization,
person=self.editor,
role=OrganizationMember.EDIT,
)
self.request = self.factory.get('/')
self.request.user = self.owner
SessionMiddleware().process_request(self.request)
MessageMiddleware().process_request(self.request)
self.view = OrganizationRemoveMemberView()
def test_register_records_header(self):
ds_pk = DataSource.objects.first().pk
csv_string = ("filename,title,document_type,product,url,organization\n"
"1.pdf,Home Depot,2,,www.homedepot.com/594.pdf,\n"
"2.pdf,Home Depot,2,,www.homedepot.com/fb5.pdf,\n")
csv_string_bytes = csv_string.encode(encoding="UTF-8", errors="strict")
in_mem_sample_csv = InMemoryUploadedFile(
io.BytesIO(csv_string_bytes),
field_name="register_records",
name="register_records.csv",
content_type="text/csv",
size=len(csv_string),
charset="utf-8",
)
data = {
"name": "Slinky",
"group_type": 1,
"downloaded_by": 1,
"downloaded_at": timezone.now(),
"download_script": 1,
"data_source": ds_pk,
"csv": in_mem_sample_csv,
}
request = self.factory.post(path=f"/datasource/{ds_pk}/datagroup_new/",
data=data)
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
middleware = MessageMiddleware()
middleware.process_request(request)
request.session.save()
request.user = User.objects.get(username="******")
resp = data_group_create(request=request, pk=6)
self.assertContains(
resp,
"CSV column titles should be ['filename', 'title',"
" 'document_type', 'url', 'organization']",
)
def test_serve_post_valid_calls_feedback_block_handler(self):
"""A valid post should call the feedback block handler.
This returns a redirect to the calling page and also uses the
Django messages framework to set a message.
"""
page = BrowsePage(title='test', slug='test')
page.content = blocks.StreamValue(page.content.stream_block,
[{
'type': 'feedback',
'value': 'something'
}], True)
save_new_page(page)
request = self.factory.post('/', {'form_id': 'form-content-0'})
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
response = page.serve_post(request)
self.assertEqual((response.status_code, response['Location']),
(302, request.path))
def test_zip_pdfs_bad_header(self):
"""
Upload a csv file with the wrong column id
"""
req = self.factory.post(path="/bulk_documents/", data=self.mng_data)
# Add the necessary middleware objects to the request
"""Annotate a request object with a session"""
middleware = SessionMiddleware()
middleware.process_request(req)
req.session.save()
"""Annotate a request object with a messages"""
middleware = MessageMiddleware()
middleware.process_request(req)
req.session.save()
req.user = User.objects.get(username="******")
csv_string = "bad_id" "\n" "122079" "\n" "121831" "\n" "121722" "\n" "121698"
in_mem_csv = string_to_csv(csv_string)
req.FILES["form-bulkformsetfileupload"] = in_mem_csv
# It should redirect because of the error
resp = views.BulkDocuments.as_view()(request=req)
resp.client = self.client
self.assertRedirects(resp, "/bulk_documents/", status_code=302)
def test_missing_preview_id_replaces_nothing(self):
request = RequestFactory().post(
"/",
{
"search": "the",
"replace": "teh",
"search_and_replace_dog_bark": "true",
"search_and_replace_dog_name": "true",
"search_and_replace_cat_bio": "true",
"search_and_replace_cat_name": "true",
"apply": "true",
},
)
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
SearchAndReplaceView.as_view(
models_and_fields=self.models_and_fields)(request)
self.lucy.refresh_from_db()
self.assertEqual(self.lucy.bio, "Grew up in the deep south.")
def test_signup(self):
request = RequestFactory().post(
reverse('account_signup'), {
'username': '******',
'email': '*****@*****.**',
'password1': '1234ABCD.*',
'password2': '1234ABCD.*',
'email': '*****@*****.**',
'email1': '*****@*****.**',
'email2': '*****@*****.**'
})
#
# response = self.client.post('/authentication/accounts/signup/',
# data, format='json')
# self.assertEqual(response.status_code, 200)
from django.contrib.messages.middleware import MessageMiddleware
from django.contrib.sessions.middleware import SessionMiddleware
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
request.user = AnonymousUser()
from .views import signup
signup(request)
data = {'username': '******', 'password': '******'}
response = self.client.post('/authentication/login/',
data,
format='json')
self.assertEqual(response.status_code, 200)
token = response.json()
response = self.client.post('/authentication/getuser/',
token,
format='json')
self.assertEqual(response.status_code, 200)
user = response.json()
self.assertEqual(user['username'], 'voter10')
def test_signup_email_twice(self):
request = RequestFactory().post(
reverse("account_signup"),
{
"username": "******",
"email": "*****@*****.**",
"email2": "*****@*****.**",
"password1": "johndoe",
"password2": "johndoe",
},
)
from django.contrib.messages.middleware import MessageMiddleware
from django.contrib.sessions.middleware import SessionMiddleware
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
request.user = AnonymousUser()
from .views import signup
signup(request)
user = get_user_model().objects.get(username="******")
self.assertEqual(user.email, "*****@*****.**")
