def test_widget_code_cache(self):
client = Client()
client.login(username='******', password='******')
widget_id = {'vendor': 'Wirecloud', 'name': 'test', 'version': '0.1'}
file_contents = self.build_simple_wgt('template1.xml', other_files=('images/catalogue.png', 'images/catalogue_iphone.png', 'doc/index.html'))
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
self.assertTrue(added)
resource_pk = resource.pk
xhtml_pk = resource.widget.pk
# Cache widget code
response = client.get(reverse('wirecloud.widget_code_entry', kwargs=widget_id))
self.assertEqual(response.status_code, 200)
old_code = response.content
resource.delete()
self.assertRaises(XHTML.DoesNotExist, XHTML.objects.get, pk=xhtml_pk)
self.assertRaises(Widget.DoesNotExist, Widget.objects.get, resource__pk=resource_pk)
self.assertRaises(CatalogueResource.DoesNotExist, CatalogueResource.objects.get, pk=resource_pk)
# Use a different xhtml code
file_contents = self.build_simple_wgt('template1.xml', b'code', other_files=('images/catalogue.png', 'images/catalogue_iphone.png', 'doc/index.html'))
resource = install_resource_to_user(self.user, file_contents=file_contents)
response = client.get(reverse('wirecloud.widget_code_entry', kwargs=widget_id))
self.assertEqual(response.status_code, 200)
new_code = response.content
self.assertNotEqual(old_code, new_code)
class AnonymousUserViewingThePages(TestCase):
def setUp(self):
from django.test import Client
self.client = Client()
def test_homepage(self):
home = self.client.get("/")
self.assertEqual(home.status_code,200)
def test_help_all_items(self):
response = self.client.get(reverse('aristotle:about_all_items'))
self.assertEqual(response.status_code,200)
def test_visible_item(self):
wg = models.Workgroup.objects.create(name="Setup WG")
ra = models.RegistrationAuthority.objects.create(name="Test RA")
wg.registrationAuthorities.add(ra)
item = models.ObjectClass.objects.create(name="Test OC",workgroup=wg)
s = models.Status.objects.create(
concept=item,
registrationAuthority=ra,
registrationDate=timezone.now(),
state=ra.locked_state
)
home = self.client.get(url_slugify_concept(item))
#Anonymous users requesting a hidden page will be redirected to login
self.assertEqual(home.status_code,302)
s.state = ra.public_state
s.save()
home = self.client.get(url_slugify_concept(item))
self.assertEqual(home.status_code,200)
def test_password_reset(self):
"""
Tests the forgotten/reset password workflow.
"""
c = Client()
resp = c.get(reverse('password_reset'))
self.assertTrue(resp.status_code, 200)
resp = c.post(reverse('password_reset'), data={'email': '*****@*****.**'})
self.assertEqual(resp.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
token = resp.context[0]['token']
uid = resp.context[0]['uid']
# Grab the token and uidb64 so that we can hit the reset url
resp = c.get(reverse('password_reset_confirm', kwargs={'token': token, 'uidb64': uid}))
self.assertEqual(resp.status_code, 200)
self.assertTrue(resp.template_name.endswith('password_reset_confirm.html'))
resp = c.post(reverse('password_reset_confirm', kwargs={'token': token, 'uidb64': uid}),
{'new_password1': 'mynewpassword', 'new_password2': 'mynewpassword'})
self.assertEqual(resp.status_code, 302)
self.assertEqual(resolve(urlsplit(resp.url).path).url_name, 'password_reset_complete')
resp = c.post(reverse('login'), {'username': '******', 'password': '******'})
# User is returned to the login page on error vs redirected by default
self.assertEqual(resp.status_code, 302)
self.assertNotEqual(resolve(urlsplit(resp.url).path).url_name, 'login')
class TestViewAct(TestCase):
'''Tests for view_act view'''
view_name = 'summer_act_view'
def setUp(self):
self.client = Client()
self.conference = ConferenceFactory(act_style="summer")
self.act = ActFactory(b_conference=self.conference)
def test_view_act_all_well(self):
url = reverse(self.view_name,
args=[self.act.pk],
urlconf='gbe.urls')
login_as(self.act.performer.performer_profile, self)
response = self.client.get(url)
test_string = 'The Summer Act'
nt.assert_equal(response.status_code, 200)
nt.assert_true(test_string in response.content)
def test_edit_bid_w_redirect(self):
'''edit_bid, not post, should take us to edit process'''
url = reverse("act_view",
args=[self.act.pk],
urlconf="gbe.urls")
login_as(self.act.performer.performer_profile, self)
response = self.client.get(url)
self.assertRedirects(
response,
reverse(self.view_name, args=[self.act.pk], urlconf="gbe.urls"))
class HostHeaderTestCase(TestCase):
"""Testing boot traffic."""
def test_underscore_host(self):
"""When host is '_'."""
self.c = Client(HTTP_HOST='_')
resp = self.c.get('/')
self.assertEqual(resp.status_code, 302)
def test_empy_host(self):
"""When host is ''."""
self.c = Client(HTTP_HOST='')
resp = self.c.get('/')
self.assertEqual(resp.status_code, 302)
def test_oddchar_host(self):
"""When host is ''."""
self.c = Client(HTTP_HOST='$')
resp = self.c.get('/')
self.assertEqual(resp.status_code, 302)
def test_wildcard_host(self):
"""When host is ''*.live.akvo-ops.org"""
self.c = Client(HTTP_HOST='*.live.akvo-ops.org')
resp = self.c.get('/')
self.assertEqual(resp.status_code, 302)
class WebhooksGET_TestCase(TestCase):
def setUp(self):
self.client = Client()
def _get_query(self, challenge='test challenge',
mode='subscribe',
token=settings.FACEBOOK_WEBHOOK_TOKEN):
return {
'hub.mode': mode,
'hub.verify_token': token,
'hub.challenge': challenge
}
def test_verification_ok(self):
url = reverse('webhooks', )
challenge = 'get OK test challenge'
response = self.client.get(url, self._get_query(challenge=challenge))
self.assertEqual(response.status_code, 200)
# must return the challange
self.assertEqual(response.content, challenge)
def test_verification_fail_with_invalid_params(self):
url = reverse('webhooks', )
response = self.client.get(url, )
self.assertEqual(response.status_code, 400)
def test_verification_fail_with_wrong_token(self):
url = reverse('webhooks', )
response = self.client.get(url, self._get_query(token='false token'))
# must fail with invalid token
self.assertEqual(response.status_code, 400)
class SmokeTest(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create(username="******",)
self.sponsor = Sponsor.objects.create(
slug="chipy",
name="Chipy"
)
def test__sponsor_detail__GET(self):
# SETUP
# TEST
response = self.client.get(
reverse_lazy('sponsor_detail', args=[self.sponsor.slug]), follow=True)
# CHECK
self.assertEqual(response.status_code, 200)
def test__sponsor_list__GET(self):
# SETUP
# TEST
response = self.client.get(
reverse_lazy('sponsor_list'), follow=True)
# CHECK
self.assertEqual(response.status_code, 200)
class PhotoTestCase(TestCase):
maxDiff = None
fixtures = ['main/tests/fixtures/competitions.yaml', 'main/tests/fixtures/prizes.yaml',
'main/tests/fixtures/votes.yaml',
'main/tests/fixtures/winners.yaml',]
def test_history_clean(self):
u = MyUser.objects.get(email='*****@*****.**')
self.assertTrue(u.is_active)
self.assertTrue(u.check_password("1"))
self.c = Client()
response = self.c.post('/api/v1/auth/login/', {'email': '*****@*****.**', 'password': '******'})
self.assertEquals(response.status_code, 200)
response = self.c.get('/api/v1/photos/?competition_id=1')
photos = json.loads(response.content)['results']
self.assertEqual(len(photos), 1)
response = self.c.get('/api/v1/competitions/1/clean_view_history/')
response = self.c.get('/api/v1/photos/?competition_id=1')
photos = json.loads(response.content)['results']
self.assertEqual(len(photos), 3)
def test_activate(self):
c = Client()
response = c.get('/signup/activate/')
self.assertEqual(response.status_code, 200)
response = c.post('/signup/activate/', {'ps1_email': '*****@*****.**'}, follow=True)
self.assertEqual(response.status_code, 200)
# "read" email
token = self.get_token()
activation_url = '/signup/activate/confirm/{}'.format(token.token)
response = c.get(activation_url)
self.assertEqual(response.status_code, 200)
post_data = {
'preferred_username': '******',
'first_name': 'Jay',
'last_name': 'Hacker',
'preferred_email': '*****@*****.**',
'token': token.token,
}
response = c.post(activation_url, post_data, follow=True)
self.assertEqual(response.status_code, 200)
jay = Person.objects.get(pk=self.person.pk)
self.assertIsNotNone(jay.user)
PS1User.objects.delete_user(jay.user)
class HomePageViewTest(BaseTest):
def setUp(self):
self.client = Client()
self.user, self.country = self.create_user_with_no_permissions()
self.assign('can_submit_responses', self.user)
self.client.login(username=self.user.username, password='******')
def test_get(self):
response = self.client.get("/")
self.assertEqual(200, response.status_code)
templates = [template.name for template in response.templates]
self.assertIn('home/index.html', templates)
def test_homepage_redirects_to_first_section_of_first_questionnaire_if_any_if_logged_in_as_data_submitter(self):
questionnaire = Questionnaire.objects.create(name="JRF", description="bla")
section = Section.objects.create(title="section", order=1, questionnaire=questionnaire, name="section")
Section.objects.create(title="section", order=2, questionnaire=questionnaire, name="section")
response = self.client.get("/")
expected_url = "/questionnaire/entry/%d/section/%d/" % (questionnaire.id, section.id)
self.assertRedirects(response, expected_url=expected_url)
def test_login_required_for_home_get(self):
self.assert_login_required('/')
def test_do_pagination(self):
# get first page for not giving integer as page number
c = Client()
response = c.get('/?page=bad_page_number')
self.assertTrue(b'Proyectos de Ley' in response.content)
# user gives empty page
response = c.get('/?page=')
self.assertTrue(b'Proyectos de Ley' in response.content)
# user gives empty page
response = c.get('/?page=100')
self.assertTrue(b'Proyectos de Ley' in response.content)
# user gives pagination more than 20
entries = []
j = 1
for i in self.dummy_items:
i['id'] = j
entries.append(Proyecto(**i))
j += 1
Proyecto.objects.bulk_create(entries)
response = c.get('/?page=21')
self.assertFalse(b'/?page=10' in response.content)
self.assertTrue(b'/?page=22' in response.content)
class SearchTestCase(TestCase):
def setUp(self):
self.client = Client()
home_url = urlresolvers.reverse('catalog_home')
response = self.client.get(home_url)
self.failUnless(response.status_code, httplib.OK)
def test_html_escaped(self):
""" search text displayed on results page is HTML-encoded """
search_term = '<script>alert(xss)</script>'
search_url = urlresolvers.reverse('search_results')
search_request = search_url + '?q=' + search_term
response = self.client.get(search_request)
self.failUnlessEqual(response.status_code, httplib.OK)
escaped_term = html.escape(search_term)
self.assertContains(response, escaped_term)
def test_RI(self):
""" search text displayed on results page is HTML-encoded """
search_term = 'RI'
search_url = urlresolvers.reverse('search_results')
search_request = search_url + '?q=' + search_term
response = self.client.get(search_request)
self.assertContains(response, 'Warwick')
def test_MA(self):
""" search text displayed on results page is HTML-encoded """
search_term = 'MA'
search_url = urlresolvers.reverse('search_results')
search_request = search_url + '?q=' + search_term
response = self.client.get(search_request)
self.assertContains(response, 'Boston')
class StudentsDetailTest(TestCase):
def setUp(self):
self.client = Client()
insert_student()
def test_detail_page_student(self):
response = self.client.get('/students/1/')
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'students/student_detail.html')
def test_mail_check_student(self):
response = self.client.get('/students/1/')
self.assertContains(response, '*****@*****.**')
def test_course_check_student(self):
response = self.client.get('/students/1/')
self.assertContains(response, 'Python/Django')
self.assertContains(response, '/courses/1/')
def test_skype_check_student(self):
response = self.client.get('/students/1/')
self.assertContains(response, 'test1')
def test_phone_check_student(self):
response = self.client.get('/students/1/')
self.assertContains(response, '099-999-99-99')
class HomeTests(BaseTestCase):
"""
Home Tests
"""
def setUp(self):
print settings.DATABASES
super(HomeTests, self).setUp()
self.client = Client()
def test_reach_homepage_no_sets(self):
response = self.client.get(reverse('home'))
self.assertEqual(response.status_code, 404)
def test_reach_homepage_with_medias(self):
# Build sets / archives / medias
for bloc in settings.HOME_SETTINGS:
if bloc['sets'] is not None:
for set_id in bloc['sets']:
try:
self.set = SetFactory(id=set_id)
except:
self.set = Set.objects.get(id=set_id)
self.archive = ArchiveFactory(set=self.set)
self.media = MediaFactory.build(confidentiality='0', archive=self.archive)
create_without_encoding(self.media)
# Create a media related to a work
self.work = WorkFactory()
self.media = MediaFactory.build(confidentiality='0', work=self.work)
create_without_encoding(self.media)
response = self.client.get(reverse('home'))
self.assertEqual(response.status_code, 200)
class ViewsTestCase(TestCase):
def setUp(self):
Group.objects.get_or_create(name="Student")
Group.objects.get_or_create(name="Teacher")
register_student("Navi_Smailliw", "makingRussiaStrong", "*****@*****.**", "Ivan", "Smailliw")
setup_test_environment()
self.client = Client()
self.client.login(username="******", password="******")
@patch('Exercise.views.get_assigned_exercise_for_students')
def test_get_exercise_for_student(self, patch):
patch.return_value = 'Dummy exercise'
response = self.client.get(reverse(get_exercise_for_student))
self.assertEqual(200, response.status_code)
self.assertTrue('exercises' in response.context)
self.assertEqual('Dummy exercise', response.context['exercises'])
@patch('Exercise.views.Exercise.objects.get')
def test_student_single_exercise_editor(self, patch):
patch.return_value = Exercise.objects.create(description='Dummy description')
response = self.client.get(reverse(student_single_exercise_editor, args=('1',)))
self.assertEqual(200, response.status_code)
self.assertTrue('ex_description' in response.context)
self.assertEqual('Dummy description', response.context['ex_description'])
patch.assert_called_with(ex_id='1')
def test_compile_code(self):
pass #TODO
class DashboardViewTests(TestCase):
def setUp(self):
self.client = Client()
self.user1 = User.objects.create_user(username='******', password='******')
def test_get_dashboard(self):
self.client.login(username=self.user1.username, password='******')
response = self.client.get('/dashboard/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Registered Device')
def test_get_dashboard_while_not_logged_in(self):
response = self.client.get('/dashboard/')
print(response)
self.assertEqual(response.status_code, 302)
self.assertRegex(response.url, r'^.*/login/\?next=/dashboard/$')
def test_post_new_device(self):
self.client.login(username=self.user1.username, password='******')
response = self.client.post('/dashboard/', data={
'device_id': '12345678',
'device_name': 'test_device'
})
self.assertEqual(response.status_code, 200)
self.assertGreater(len(response.context['devices']), 0)
def test_poll(self):
self.feed.poll()
self.assertEqual(self.feed.editions.count(), 1)
edition = self.feed.editions.all()[0]
self.assertEqual(edition.articles.count(), 55)
self.assertEqual(edition.articles.filter(section__slug="newswire").count(), 20)
self.assertEqual(edition.articles.filter(section__slug="film").count(), 15)
self.assertEqual(edition.articles.filter(section__slug="tv-club").count(), 20)
c = Client()
response = c.get("/%s/latest.xml" % self.feed.slug)
self.assertRedirects(response, edition.get_absolute_url(), status_code=302)
response = c.get(edition.get_absolute_url())
self.assertEqual(response.status_code, 200)
for section_slug in ["newswire", "film", "tv-club"]:
response = c.get(reverse("pubfeeds.core.views.section", args=(edition.feed.slug, edition.id, section_slug)))
self.assertEqual(response.status_code, 200)
for article in edition.articles.all():
response = c.get(article.get_absolute_url())
self.assertEqual(response.status_code, 200)
class ViewTests(TestCase):
fixtures = ['initial_data.json']
def setUp(self):
self.client = Client()
def test_page(self):
pages = Page.objects.all()
assert_not_equal(pages.count(), 0)
for page in pages:
if not page.is_public():
expected = 404
elif page.slug in ('blog', 'index', 'talk',):
# Blog front page is explicitly redirected to the latest post.
# We test this is the blog app, so this is just special-cased.
# The index page is special-cased to redirect to pages:index.
expected = 302
else:
expected = 200
response = self.client.get(page.get_absolute_url())
eq_(response.status_code, expected, page.title)
def test_index(self):
eq_(self.client.get('/').status_code, 200)
class HomePageTests(TestCase):
def setUp(self):
self.client = Client()
self.User = get_user_model()
self.link_home = reverse('home')
self.link_requests = reverse('requests')
def test_hardcoded_data(self):
'''Checking presence of hardcoded data
'''
response = self.client.get(self.link_home)
self.assertContains(response, 'Enough is enough')
def test_no_user(self):
'''Page contains hard-coded data in case of no users in DB
'''
self.User.objects.all().delete()
response = self.client.get(self.link_home)
self.assertContains(response, 'Enough is enough')
def test_more_than_one_user(self):
'''Page still contains 'admin' user data in case of more than one user in DB
'''
self.User.objects.create_user(username='******')
response = self.client.get(self.link_home)
self.assertContains(response, 'Enough is enough')
def test_requests_link(self):
'''Page contains the link to the 'requests' page
'''
response = self.client.get(self.link_home)
soup = bss.BeautifulSoupSelect(response.content)
self.assertTrue(soup('a[href="%s"]' % self.link_requests))
class DailyEventViewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = PyDayUser.objects._create_user("*****@*****.**", "secret",
"MynameisWhat",
"MynameisWho")
self.client.login(email='*****@*****.**', password='******')
def test_get_wrong_date(self):
with self.assertTemplateUsed("error.html"):
response = self.client.get('/calendar/daily_events/6000/60/60')
self.assertContains(response, 'Impossible date')
def test_get_right_date(self):
with self.assertTemplateUsed('daily_event.html'):
response = self.client.get('/calendar/daily_events/6000/10/10')
self.assertEqual(response.status_code, 200)
def test_no_date(self):
date = datetime.now()
with self.assertTemplateUsed('daily_event.html'):
response = self.client.get(reverse("pyday_calendar:daily_events"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Events for {} ".format(date.day))
class AlarmViewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = PyDayUser.objects._create_user("*****@*****.**", "secret",
"MynameisWhat",
"MynameisWho")
self.client.login(email='*****@*****.**', password='******')
def test_get(self):
with self.assertTemplateUsed("create_alarm.html"):
self.client.get(reverse("pyday_alarms:alarms"))
def test_post(self):
with self.assertTemplateUsed("error.html"):
response = self.client.post(reverse("pyday_alarms:alarms"),
{'date': '07/01/2016', 'hour': '1',
'mins': '0', 'message': 'haha'},
follow=True)
self.assertContains(response, "Raspberry!")
def test_post_invalid_form(self):
with self.assertTemplateUsed("error.html"):
response = self.client.post(reverse("pyday_alarms:alarms"), {})
self.assertContains(response, "Invalid form")
class StatusViewsTest(ESTestCase):
@classmethod
def setUpTestData(cls):
super(ESTestCase, cls).setUpTestData()
def setUp(self):
self.client = Client()
def test_status_health(self):
"""check health url"""
# fill data in elastic.
fixture_utils.create_nummeraanduiding_fixtures()
create_hr_data()
# load all BAG and HR in elastic.
self.rebuild_elastic_index()
# give elastic time to proces new data
time.sleep(2)
response = self.client.get('/status/health')
# Making sure its a 200
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b'Data OK')
def test_status_health_not_ok(self):
# empty the indexes.
call_command(
'elastic_indices', '--recreate', 'hr', 'bag', verbosity=0)
response = self.client.get('/status/health')
# Making sure its a 500
self.assertEqual(response.status_code, 500)
self.assertEqual(response.content, b'Elastic data missing.')
class ClientTests(TestCase):
def setUp(self):
self.c = Client()
self.authToken = "77d254b3caba4fb29747958138136ffa"
self.url = "http://130.206.80.61:35357/v2.0"
self.mockedClient = client
self.auth = mock()
self.auth.stub("authenticate")
self.auth.__setattr__("auth_token", self.authToken)
when(self.auth.stub("tokens")).authenticate(token="1234").thenReturn(True)
when(AuthorizationManager.AuthorizationManager)\
.checkToken(None, "1234", "tenantId").thenReturn(True)
when(AuthorizationManager.AuthorizationManager)\
.checkToken(None, "12345", "tenantId").thenRaise(AuthorizationFailure())
when(AuthorizationManager.AuthorizationManager).\
get_auth_token("admin", "openstack").thenReturn(self.authToken)
def test_servers_view_url(self):
response = self.c.get('/v1.0/tenantId/servers/', **{'HTTP_X_AUTH_TOKEN': '1234'})
def test_server_rules_view_url(self):
response = self.c.get('/v1.0/tenantId/servers/rules', **{'HTTP_X_AUTH_TOKEN': '1234'})
def test_tenant_info_view_url_fail(self):
""" Test if using an invalid token to access tenant_info resource returns an AuthorizationFailure Exception.
"""
try:
response = self.c.get('/v1.0/tenantId', **{'HTTP_X_AUTH_TOKEN': '12345'})
except AuthorizationFailure as ex:
self.assertRaises(ex)
class ArticleTest(TestCase):
def setUp(self):
self.client = Client()
self.factory = RequestFactory()
def test_validate_article_edition(self):
user2 = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
article = Article()
article.title = "nicetitle"
article.content = "nicecontent"
article.create_user = user2
article.create_user.id = user2.id
article.save()
self.client.login(username="******", password="******")
response = self.client.get(reverse('edit_article', kwargs={'id': '1'}))
self.assertEqual(response.status_code, 302)
response = self.client.post(reverse('edit_article',
kwargs={'id': '1'}))
self.assertEqual(response.status_code, 302)
self.client.login(username="******", password="******")
response = self.client.get(reverse('edit_article', kwargs={'id': '1'}),
user=user2)
self.assertEqual(response.status_code, 200)
response = self.client.post(reverse('edit_article',
kwargs={'id': '1'}))
self.assertEqual(response.status_code, 200)
class CitationFormClientTest( TestCase ):
""" Checks citation form via Client. """
def setUp(self):
self.client = Client()
def test_plain_get(self):
""" Checks plain form. """
response = self.client.get( '/find/citation_form/' ) # project root part of url is assumed
self.assertEqual( 200, response.status_code )
self.assertEqual( True, '<input type="radio" name="form" value="article">Article' in response.content.decode('utf-8') )
for key in ['article_form', 'book_form', 'csrf_token', 'form_type', 'messages', 'problem_link' ]:
self.assertTrue( key in response.context.keys(), 'key `%s` not found' % key )
def test_get_isbn_parameter(self):
""" Checks incorporation of param into form. """
response = self.client.get( '/find/citation_form/?isbn=9780439339117' ) # project root part of url is assumed
# print response.content
self.assertEqual( 200, response.status_code )
self.assertEqual( True, '9780439339117' in response.content.decode('utf-8') )
self.assertEqual( 'book', response.context['form_type'] )
# pprint.pformat( response.context )
for key in ['article_form', 'book_form', 'csrf_token', 'form_type', 'messages', 'problem_link' ]:
self.assertTrue( key in response.context.keys(), 'key `%s` not found' % key )
def test_get_doi_parameter(self):
""" Checks incorporation of param into form. """
response = self.client.get( '/find/citation_form/?doi=12611747' ) # project root part of url is assumed
# print response.content
self.assertEqual( 200, response.status_code )
self.assertEqual( True, '12611747' in response.content.decode('utf-8') )
self.assertEqual( 'article', response.context['form_type'] )
pprint.pformat( response.context )
for key in ['article_form', 'book_form', 'csrf_token', 'form_type', 'messages', 'problem_link' ]:
self.assertTrue( key in response.context.keys(), 'key `%s` not found' % key )
def nested_view(request):
"""
A view that uses test client to call another view.
"""
c = Client()
c.get("/no_template_view/")
return render(request, 'base.html', {'nested': 'yes'})
class EndpointAuthenticationTestCase(TestCase):
def setUp(self):
self.c = Client()
self.user = User.objects.create_user(username="******", password="******")
def tearDown(self):
for role in self.user.roles.all():
role.delete()
def test_endpoints_require_token_auth(self):
url = reverse('user-me')
response = self.c.get(url)
assert response.status_code == 401, "401: Authentication required"
def test_director_can_see_anyone(self):
url = reverse('user-me')
self.user.add_role('Director')
response = self.c.get(
url, HTTP_AUTHORIZATION="Token {0}" . format(self.user.get_token()))
assert response.status_code == 200, "Director can view any user"
def test_user_can_see_self(self):
url = reverse('user-me')
response = self.c.get(
url, HTTP_AUTHORIZATION="Token {0}" . format(self.user.get_token()))
assert response.status_code == 200, "User can see self"
class UserLogoutTest(TestCase):
"""User logout test class."""
def setUp(self):
# create users
create_test_users(self)
# launch client
self.client = Client()
def test_urls(self):
urls = [
{
'url': '/logout/',
'status': 302,
'template': 'user/user_login.html'
},
]
test_urls(self, urls)
def test_logout(self):
# login with user
login(self, self.user)
response = self.client.get('/logout/')
# assert redirection is ok
self.assertEqual(response.status_code, 302)
# assert user isn't connected anymore
self.assertEqual(hasattr(response.context, 'user'), False)
response = self.client.get('/logout/', follow=True)
# assert redirection is ok
self.assertEqual(response.status_code, 200)
self.assertEqual(response.templates[0].name,
'user/user_login.html')
class PasswordResetChangeTest(ShadowConTestCase):
def setUp(self):
self.client = Client()
def run_test(self, key):
response = self.client.get(reverse(key))
self.assertSectionContains(response, "ShadowCon 2016", "title")
return response
def test_login(self):
response = self.run_test('login')
self.assertSectionContains(response, '<p><a href="%s">%s</a></p>' % (reverse('password_reset'),
'Lost password\\?'),
'section id="main" role="main"', '/section')
self.assertSectionContains(response, '<p><a href="%s">%s</a></p>' % (reverse('convention:new_user'),
'Create New Account'),
'section id="main" role="main"', '/section')
def test_logout(self):
response = self.run_test('logout')
self.assertSectionContains(response, 'You have successfully logged out',
'section id="main" role="main"', '/section')
def test_password_change(self):
self.client.login(username="******", password="******")
response = self.run_test('password_change')
self.assertSectionContains(response, 'Enter new password', 'section id="main" role="main"', '/section')
def test_password_change_done(self):
self.client.login(username="******", password="******")
response = self.run_test('password_change_done')
self.assertSectionContains(response, '<h2>Password Changed</h2>', 'section id="main" role="main"', '/section')
def test_password_reset(self):
response = self.run_test('password_reset')
self.assertSectionContains(response, 'Forgotten your password\\? Enter your',
'section id="main" role="main"', '/section')
def test_password_reset_done(self):
response = self.run_test('password_reset_done')
self.assertSectionContains(response, 'Password reset sent', 'section id="main" role="main"', '/section')
def test_password_reset_confirm_invalid_link(self):
response = self.client.get(reverse('password_reset_confirm', args=["invalid", "4a8-cd1bf13135ee4cae7176"]))
self.assertSectionContains(response, "ShadowCon 2016", "title")
self.assertSectionContains(response, 'The password reset link was invalid',
'section id="main" role="main"', '/section')
def test_password_reset_confirm_valid_link(self):
self.client.post(reverse('password_reset'), {"email": "*****@*****.**"})
email = self.get_email()
start = str(email.body).index('/reset')
stop = str(email.body).index('Your username, in case you\'ve forgotten: user')
link = str(email.body)[start:stop].strip()
response = self.client.get(link)
self.assertSectionContains(response, "ShadowCon 2016", "title")
self.assertSectionContains(response, 'Please enter your new password twice',
'section id="main" role="main"', '/section')
class MontlyEventViewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = PyDayUser.objects._create_user("*****@*****.**", "secret",
"MynameisWhat",
"MynameisWho")
def test_get_not_logged(self):
response = self.client.get(reverse("pyday_calendar:monthly_events"),
follow=True)
self.assertEqual(response.redirect_chain,
[('/social/register/?next=/calendar/monthly_events/', 302)])
def test_get_logged(self):
self.client.login(email='*****@*****.**', password='******')
with self.assertTemplateUsed("monthly_event.html"):
resp = self.client.get(reverse("pyday_calendar:monthly_events"))
self.assertEqual(resp.status_code, 200)
def test_post_wrong_date(self):
self.client.login(email='*****@*****.**', password='******')
with self.assertTemplateUsed("error.html"):
self.client.post(reverse("pyday_calendar:monthly_events"), {
"date": "60/2016"})
def test_post_right_date(self):
self.client.login(email='*****@*****.**', password='******')
with self.assertTemplateUsed("monthly_event.html"):
self.client.post(reverse("pyday_calendar:monthly_events"), {
"date": "6/2016"})
class BaseTestCase(TestCase):
def setUp(self):
# This comment is for crawling setUp.
# I leave this implementation for the case that we must use crawled data
#
# admin = User(username='******', is_staff=True)
# admin.set_password('password')
# admin.save()
# client = Client()
# client.login(username='******', password='******')
#
# response = client.post('/manager/crawlers/', data={
# 'year': 2018,
# 'semester': '1학기',
# })
# crawler_id = response.json()['id']
#
# from time import sleep
# for i in range(30):
# response = client.get('/manager/crawlers/{}/'.format(crawler_id))
# sleep(1)
# assert 'running' in response.json()['status']
#
# client.put('/manager/crawlers/{}/'.format(crawler_id))
# for i in range(30):
# response = client.get('/manager/crawlers/{}/'.format(crawler_id))
# if 'running' not in response.json()['status']:
# break
# sleep(1)
# assert 'canceled' in response.json()['status']
college1 = College.objects.create(name='college1')
department1 = Department.objects.create(name='department1',
college=college1)
major1 = Major.objects.create(name='major1', department=department1)
college2 = College.objects.create(name='college2')
department2 = Department.objects.create(name='department2',
college=college2)
college3 = College.objects.create(name='college3')
course1 = Course.objects.create(name='course1',
code='code1',
type='전필',
grade=3,
credit=4,
college=college1,
department=department1)
course2 = Course.objects.create(name='course2',
code='code2',
type='전선',
grade=2,
credit=3,
college=college1,
department=department1,
major=major1)
course3 = Course.objects.create(name='course3',
code='code3',
type='교양',
grade=1,
credit=2,
college=college2,
department=department2)
time_slot1 = TimeSlot.objects.create(day_of_week='월',
start_time='12:00',
end_time='13:15')
time_slot2 = TimeSlot.objects.create(day_of_week='수',
start_time='12:00',
end_time='13:15')
time_slot3 = TimeSlot.objects.create(day_of_week='금',
start_time='16:00',
end_time='18:00')
lecture = Lecture.objects.create(course=course1,
year=2018,
semester='1학기',
number='001',
instructor='가나다',
note='')
lecture.time_slots.add(time_slot1)
lecture.time_slots.add(time_slot2)
lecture.time_slots.add(time_slot3)
time_slot1 = TimeSlot.objects.create(day_of_week='월',
start_time='14:00',
end_time='15:15')
time_slot2 = TimeSlot.objects.create(day_of_week='수',
start_time='14:00',
end_time='15:15')
time_slot3 = TimeSlot.objects.create(day_of_week='목',
start_time='9:00',
end_time='10:45')
lecture = Lecture.objects.create(course=course1,
year=2018,
semester='1학기',
number='002',
instructor='ABC',
note='RRR')
lecture.time_slots.add(time_slot1)
lecture.time_slots.add(time_slot2)
lecture.time_slots.add(time_slot3)
time_slot1 = TimeSlot.objects.create(day_of_week='월',
start_time='12:00',
end_time='13:15')
time_slot2 = TimeSlot.objects.create(day_of_week='수',
start_time='12:00',
end_time='13:15')
time_slot3 = TimeSlot.objects.create(day_of_week='금',
start_time='16:00',
end_time='18:00')
lecture = Lecture.objects.create(course=course3,
year=2018,
semester='1학기',
number='001',
instructor='가나다',
note='')
lecture.time_slots.add(time_slot1)
lecture.time_slots.add(time_slot2)
lecture.time_slots.add(time_slot3)
time_slot1 = TimeSlot.objects.create(day_of_week='월',
start_time='12:00',
end_time='13:15')
time_slot2 = TimeSlot.objects.create(day_of_week='수',
start_time='12:00',
end_time='13:15')
time_slot3 = TimeSlot.objects.create(day_of_week='금',
start_time='16:00',
end_time='18:00')
lecture = Lecture.objects.create(course=course2,
year=2018,
semester='여름학기',
number='001',
instructor='가나다',
note='')
lecture.time_slots.add(time_slot1)
lecture.time_slots.add(time_slot2)
lecture.time_slots.add(time_slot3)
data = {
'username': '******',
'password': make_password('password'),
'email': '*****@*****.**',
'grade': 3,
'college_id': 1,
'department_id': 1,
}
self.student = Student.objects.create(**data)
data = {
'username': '******',
'password': make_password('password'),
'email': '*****@*****.**',
'grade': 3,
'college_id': 1,
'department_id': 1,
}
self.student2 = Student.objects.create(**data)
data = {
'username': '******',
'password': make_password('password'),
'email': '*****@*****.**',
'grade': 3,
'college_id': 1,
'department_id': 1,
}
self.student3 = Student.objects.create(**data)
self.client = Client()
self.sign_in()
def sign_in(self, username='******'):
self.assertTrue(
self.client.login(username=username, password='******'))
def get_test(self, url, success=True, status_code=None):
response = self.client.get(url)
print(response.json())
self.assertEqual(
response.status_code,
status_code if status_code else 200 if success else 400)
return response
def post_test(self, url, data, success=True, status_code=None):
response = self.client.post(url, data=data)
print(response.json())
self.assertEqual(
response.status_code,
status_code if status_code else 201 if success else 400)
return response
def put_test(self, url, data, success=True, status_code=None):
response = self.client.put(url,
data=json.dumps(data),
content_type='application/json')
print(response.json())
self.assertEqual(
response.status_code,
status_code if status_code else 200 if success else 400)
return response
def patch_test(self, url, data, success=True, status_code=None):
response = self.client.patch(url,
data=json.dumps(data),
content_type='application/json')
print(response.json())
self.assertEqual(
response.status_code,
status_code if status_code else 200 if success else 400)
return response
def delete_test(self, url, status_code=None):
response = self.client.delete(url)
print(response.status_code)
self.assertEqual(response.status_code,
status_code if status_code else 204)
return response
class StudentandRubricViewTest(TestCase):
def add_two_classes_to_semester_add_two_students_to_class_add_one_row(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
self.test_user = User.objects.create_superuser(self.username, self.email, self.password)
login = self.client.login(username=self.username, password = self.password)
jane = User.objects.create(username="******")
intasc1 = Standard.objects.create(name="INTASC 1")
caep1 = Standard.objects.create(name="CAEP 1")
semester = Semester.objects.create(text="201530")
edclass1 = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="5000", teacher=self.test_user, crn=2222, semester=semester)
edclass2 = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="6000", teacher=self.test_user, crn=3333, semester=semester)
edclass = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="5111", teacher=jane, crn=4444, semester=semester)
#semester.classes.add(edclass1)
#semester.classes.add(edclass2)
#semester.classes.add(edclass)
bob = Student.objects.create(lastname="DaBuilder", firstname="Bob",lnumber="21743148")
jane = Student.objects.create(lastname="Doe", firstname="Jane",lnumber="21743149")
kelly = Student.objects.create(lastname="Smith", firstname="Kelly", lnumber="33333333")
kellyenrollment = Enrollment.objects.create(student=kelly, edclass=edclass)#, semester=semester)
bobenrollment = Enrollment.objects.create(student=bob, edclass=edclass1)#, semester=semester), semester=semester)
bobenrollment1 = Enrollment.objects.create(student=bob, edclass=edclass2)#, semester=semester), semester=semester)
janeenrollment = Enrollment.objects.create(student=jane, edclass=edclass1)#, semester=semester), semester=semester)
janeenrollment2 = Enrollment.objects.create(student=jane, edclass=edclass2)#, semester=semester), semester=semester)
writingrubric = Rubric.objects.create(name="writingrubric")
row1 = Row.objects.create(excellenttext="THE BEST!",
proficienttext="THE SECOND BEST!",
satisfactorytext="THE THIRD BEST!",
unsatisfactorytext="YOU'RE LAST",rubric=writingrubric, name="Excellence is a habit")
row1.standards.add(intasc1)
row2 = Row.objects.create(excellenttext="THE GREATEST!",
proficienttext="THE 2nd BEST!",
satisfactorytext="THE THIRD BEST!",
unsatisfactorytext="YOU'RE LAST",rubric=writingrubric)
row2.standards.add(caep1)
edclasssemester = Assignment.objects.create( edclass=edclass, assignmentname="Writing Assignment", keyrubric=writingrubric)
edclasssemester1 = Assignment.objects.create( edclass=edclass1, assignmentname="Writing Assignment", keyrubric=writingrubric)
edclasssemester2 = Assignment.objects.create(edclass=edclass2, assignmentname="Writing Assignment", keyrubric=writingrubric)
def test_rubric_page_not_viewable_by_dasterdaly_bob(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get('/assessment/201530/EG5111/writingassignment1/33333333/')
self.assertEquals(response.status_code, 404)
def test_class_page_requires_login(self):
response = self.client.get("/assessment/201530/EG500001", follow=True)
self.assertIn("Username", response.content.decode())
def test_student_and_rubric_view_returns_correct_template(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
self.assertTemplateUsed(response, 'rubricapp/rubric.html')
def test_student_and_rubric_view_shows_student_name(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
self.assertContains(response, "DaBuilder, Bob")
def test_student_and_rubric_view_shows_row_name(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
self.assertContains(response, "Excellence is a habit")
def test_student_and_rubric_view_has_excellent_grade(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
self.assertContains(response, "Excellent")
def test_rubric_shows_a_cell_under_excellent(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
self.assertContains(response, "THE BEST!")
def test_rubric_page_shows_rubric_name(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
self.assertContains(response, "Writing Rubric")
def test_rubric_page_can_take_post_request(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data ={"form-0-name": "Excellence is a habit",
"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"1",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
self.assertEqual(response.status_code, 302)
def test_post_request_creates_new_rubric_for_the_enrollment(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
writingrubric = Rubric.objects.get(name="writingrubric")
row = Row.objects.filter(rubric=writingrubric)
self.assertEqual(row.count(), 2)
#Why do you need to get the response before you can post it?????
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data ={"form-0-name": "Excellence is a habit",
"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"1",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
student = Student.objects.get(lnumber="21743148")
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000", sectionnumber="01")
writingassignment = Assignment.objects.get(pk=1)
bobenroll = Enrollment.objects.get(edclass=edclass, student=student)
bobrubricobject = RubricData.objects.get(assignment=writingassignment, enrollment=bobenroll)
self.assertEqual(bobrubricobject.completedrubric.name, "EG50000121743148201530WritingAssignment")
def test_rubric_page_redirects_correct_page(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
#soup = BeautifulSoup(response.content)
#form = soup.find('form')
#print(form)
data ={"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"1",
"form-1-name": "NONE",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
self.assertEqual(response['location'], '/assessment/201530/EG500001/writingassignment1/')
def test_post_request_updates_correct_model(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data ={"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"1",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
student = Student.objects.get(lnumber="21743148")
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000")
bobenrollment = Enrollment.objects.get(student=student, edclass=edclass)
bobrubricenroll = RubricData.objects.get(assignment__pk=1, enrollment=bobenrollment)
row = Row.objects.get(excellenttext="THE BEST!", rubric__name=bobrubricenroll.completedrubric.name)
self.assertEqual(row.row_choice, "1")
def test_post_request_does_not_take_0_value(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data ={"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"0",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
self.assertContains(response, "You must choose a value for all rows!" )
def test_post_request_shows_row_names_if_empty_row_submitted(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data ={"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"0",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
self.assertContains(response, "You must choose a value for all rows!")
self.assertContains(response, "Excellence is a habit" )
def test_post_request_with_0_value_doesnt_return_null_row_values(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data ={"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"0",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
self.assertContains(response, "THE BEST!" )
def test_post_request_does_not_create_blank_enrollment_if_empty_row(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data ={"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"0",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
student = Student.objects.get(lnumber="21743148")
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000")
bobenrollment = Enrollment.objects.filter(student=student, edclass=edclass)
self.assertEqual(bobenrollment.count(), 1)
def test_get_request_for_student_rubric_page_returns_rubric_if_completedrubric_false(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
bobenrollment = Enrollment.objects.get(student__lastname="DaBuilder", edclass__subject="EG", edclass__coursenumber="5000")
Rubric.objects.create(name="EG50000121743148201530")
#bobenrollment.rubriccompleted = False
response = self.client.get("/assessment/201530/EG500001/WritingAssignment1/21743148/")
self.assertContains(response, "id_form-TOTAL_FORMS")
def test_rubric_for_different_semester_doesnt_shows_up_in_correct_semester(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
newsemester = Semester.objects.create(text="201610")
bob = User.objects.get(username="******")
badrubric = Rubric.objects.create()
badrow = Row.objects.create(excellenttext="STOP",
proficienttext="STOP",
satisfactorytext="STOP",
unsatisfactorytext="STOP",rubric=badrubric)
edclass = EdClasses.objects.create(subject="EG", sectionnumber="01", coursenumber="5000", crn=7777, teacher=bob, semester=newsemester)#, semester=newsemester)
edclassnewsemester = Assignment.objects.create(edclass=edclass, assignmentname="Writing Assignment", keyrubric=badrubric)
#edclassnewsemester.keyrubric.add(badrubric)
george = Student.objects.create(lastname="Harrison", firstname="Georgeo", lnumber="21743444")
newgeorgeenrollment = Enrollment.objects.create(student=george, edclass=edclass)#,semester=newsemester)
response = self.client.get('/assessment/201610/EG500001/WritingAssignment'+ str(edclassnewsemester.pk) +'/21743444/')
self.assertContains(response, "STOP")
def test_rubric_for_different_semester_doesnt_show_up_wrong_semester(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
newsemester = Semester.objects.create(text="201610")
badrubric = Rubric.objects.create()
badrow = Row.objects.create(excellenttext="STOP",
proficienttext="STOP",
satisfactorytext="STOP",
unsatisfactorytext="STOP",rubric=badrubric)
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000")#Should be in 201530
edclassnewsemester = Assignment.objects.create(edclass=edclass, keyrubric=badrubric)
#edclassnewsemester.keyrubric.add(badrubric)
george = Student.objects.create(lastname="Harrison", firstname="Georgeo", lnumber="5555")
newgeorgeenrollment = Enrollment.objects.create(student=george, edclass=edclass)#,semester=newsemester)
response = self.client.get('/assessment/201530/EG500001/writingassignment1/21743148/')
self.assertNotContains(response, "STOP")
def test_rubric_created_also_copies_standards(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data = {"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice": "1",
"form-1-name": "None",
"form-1-row_choice": "2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000")
bobdabuilder = Student.objects.get(lastname="DaBuilder")
bobdabuilderenroll = Enrollment.objects.get(student=bobdabuilder, edclass=edclass)
bobrubricdata = RubricData.objects.get(enrollment=bobdabuilderenroll)
row1 = Row.objects.get(rubric__name="writingrubric", excellenttext="THE BEST!")
row = Row.objects.get(excellenttext="THE BEST!", rubric=bobrubricdata.completedrubric)
self.assertEquals("INTASC 1", row.standards.all()[0].name)
def test_rubric_created_also_copies_two_standards(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data = {"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice": "1",
"form-1-name": "None",
"form-1-row_choice": "2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
bobdabuilder = Student.objects.get(lastname="DaBuilder")
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000")
bobdabuilderenroll = Enrollment.objects.get(student=bobdabuilder, edclass=edclass)
bobrubricdata = RubricData.objects.get(enrollment=bobdabuilderenroll)
row = Row.objects.get(excellenttext="THE BEST!", rubric=bobrubricdata.completedrubric)
row2 = Row.objects.get(excellenttext="THE GREATEST!", rubric=bobrubricdata.completedrubric)
self.assertEquals("INTASC 1", row.standards.all()[0].name)
self.assertEquals("CAEP 1", row2.standards.all()[0].name)
def test_rubric_copies_multiple_standards(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
rowbeforepost = Row.objects.get(excellenttext="THE BEST!", rubric__name="writingrubric")
intasc2 = Standard.objects.create(name="Intasc 2")
rowbeforepost.standards.add(intasc2)
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data = {"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice": "1",
"form-1-name": "None",
"form-1-row_choice": "2",
"form-0-id": "3",
"form-1-id": "4"}
self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
bobdabuilder = Student.objects.get(lastname="DaBuilder")
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000")
bobdabuilderenroll = Enrollment.objects.get(student=bobdabuilder, edclass=edclass)
bobrubricdata = RubricData.objects.get(enrollment=bobdabuilderenroll)
row = Row.objects.get(excellenttext="THE BEST!", rubric=bobrubricdata.completedrubric)
self.assertEquals(2, row.standards.count())
def test_rubric_copies_same_standard_different_rows(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
rowbeforepost = Row.objects.get(proficienttext="THE 2nd BEST!", rubric__name="writingrubric")
intasc1 = Standard.objects.get(name="INTASC 1")
rowbeforepost.standards.add(intasc1)
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data = {"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice": "1",
"form-1-name": "None",
"form-1-row_choice": "2",
"form-0-id": "3",
"form-1-id": "4"}
self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
bobdabuilder = Student.objects.get(lastname="DaBuilder")
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000")
bobdabuilderenroll = Enrollment.objects.get(student=bobdabuilder, edclass=edclass)
bobrubricdata = RubricData.objects.get(enrollment=bobdabuilderenroll)
row2 = Row.objects.get(proficienttext="THE 2nd BEST!", rubric=bobrubricdata.completedrubric)
row1 = Row.objects.get(excellenttext="THE BEST!", rubric=bobrubricdata.completedrubric)
self.assertEquals(2, row2.standards.count())
self.assertEquals("CAEP 1", row2.standards.all()[0].name)
self.assertEquals("INTASC 1", row2.standards.all()[1].name)
self.assertEquals("INTASC 1", row1.standards.all()[0].name)
def test_rubric_copies_template_name(self):
self.add_two_classes_to_semester_add_two_students_to_class_add_one_row()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/21743148/")
data = {"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice": "1",
"form-1-name": "None",
"form-1-row_choice": "2",
"form-0-id": "3",
"form-1-id": "4"}
self.client.post("/assessment/201530/EG500001/writingassignment1/21743148/", data)
bobdabuilder = Student.objects.get(lastname="DaBuilder")
edclass = EdClasses.objects.get(subject="EG", coursenumber="5000")
bobdabuilderenroll = Enrollment.objects.get(student=bobdabuilder, edclass=edclass)
bobrubricdata = RubricData.objects.get(enrollment=bobdabuilderenroll)
row2 = Row.objects.get(proficienttext="THE 2nd BEST!", rubric=bobrubricdata.completedrubric)
self.assertEquals("writingrubric", row2.templatename)
class AssignmentViewTest(TestCase):
def add_two_classes_to_semester_add_two_students_to_class(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
self.test_user = User.objects.create_superuser(self.username, self.email, self.password)
login = self.client.login(username=self.username, password = self.password)
jane = User.objects.create(username="******")
first_semester = Semester.objects.create(text='201530')
edClass = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="5000", teacher=self.test_user, crn=2222, semester=first_semester)
edClass2 = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="6000", teacher=self.test_user, crn=3333, semester=first_semester)
edClass1 = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="5111", teacher=jane, crn=4444, semester=first_semester)
#first_semester.classes.add(edClass)
#first_semester.classes.add(edClass2)
#first_semester.classes.add(edClass1)
writingrubric = Rubric.objects.create(name="Writing Rubric")
unitrubric = Rubric.objects.create(name="Unit Rubric")
unitassignment = Assignment.objects.create(edclass=edClass, assignmentname="Unit Plan", keyrubric=unitrubric)
writingassignment = Assignment.objects.create(edclass=edClass, assignmentname="Writing Assignment", keyrubric=writingrubric)
edclasssemester1 = Assignment.objects.create(edclass=edClass2, keyrubric=unitrubric)
edclasssemester2 = Assignment.objects.create(edclass=edClass1, keyrubric=unitrubric)
#unitassignment.keyrubric.add(unitrubric)
#writingassignment.keyrubric.add(writingrubric)
#edclasssemester1.keyrubric.add(unitrubric)
# edclasssemester2.keyrubric.add(unitrubric)
row1 = Row.objects.create(excellenttext="THE BEST!",
proficienttext="THE SECOND BEST!",
satisfactorytext="THE THIRD BEST!",
unsatisfactorytext="YOU'RE LAST",rubric=writingrubric)
row2 = Row.objects.create(excellenttext="THE GREATEST!",
proficienttext="THE SECOND BEST!",
satisfactorytext="THE THIRD BEST!",
unsatisfactorytext="YOU'RE LAST",rubric=writingrubric)
row1 = Row.objects.create(excellenttext="BAD!",
proficienttext="BAD!",
satisfactorytext="BAD!",
unsatisfactorytext="BAD!",rubric=unitrubric)
row2 = Row.objects.create(excellenttext="BAD!",
proficienttext="BAD!",
satisfactorytext="BAD!",
unsatisfactorytext="BAD!",rubric=unitrubric)
bob = Student.objects.create(lastname="DaBuilder", firstname="Bob", lnumber="21743148")
jane = Student.objects.create(lastname="Doe", firstname="Jane", lnumber="21743149")
kelly = Student.objects.create(lastname="Smith", firstname="Kelly", lnumber="33333333")
bobenrollment = Enrollment.objects.create(student=bob, edclass=edClass)#, semester=first_semester)
janeenrollment = Enrollment.objects.create(student=jane,edclass=edClass)#, semester=first_semester), semester=first_semester)
bobenrollment2 = Enrollment.objects.create(student=bob,edclass=edClass2)#, semester=first_semester), semester=first_semester)
janeenrollment2 = Enrollment.objects.create(student=jane,edclass=edClass2)#, semester=first_semester)
kellyenrollment = Enrollment.objects.create(student=kelly, edclass=edClass1)#, semester=first_semester)
def test_assignment_page_resolves_to_assingment_function(self):
self.add_two_classes_to_semester_add_two_students_to_class()
found = resolve('/assessment/201530/EG500001/writingassignment1/')
self.assertEqual(found.func, student_page)
def test_student_can_have_more_than_one_assignment_in_course(self):
self.add_two_classes_to_semester_add_two_students_to_class()
edclass = EdClasses.objects.get(crn=2222)
writingassignment = Assignment.objects.get(assignmentname="Writing Assignment")
unitassignment = Assignment.objects.get(assignmentname="Unit Plan")
data ={"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"2",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
response = self.client.post("/assessment/201530/EG500001/writingassignment{}/21743148/".format(writingassignment.pk), data)
found = self.client.get('/assessment/201530/EG500001/unitplan{}/21743148/'.format(unitassignment.pk))
self.assertContains(found, "BAD!")
def test_two_assignments_same_class_same_rubric(self):
self.add_two_classes_to_semester_add_two_students_to_class()
edclass = EdClasses.objects.get(crn=2222)
writingrubric = Rubric.objects.get(name="Writing Rubric")
happypaper = Assignment.objects.create(assignmentname="Happy Paper", edclass=edclass, keyrubric=writingrubric)
#happypaper.keyrubric.add(writingrubric)
bobenrollment = Enrollment.objects.get(edclass=edclass, student__lastname="DaBuilder")
writingassignment = Assignment.objects.get(assignmentname="Writing Assignment")
data ={"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-0-name": "Excellence is a habit",
"form-0-row_choice":"2",
"form-1-name": "None",
"form-1-row_choice":"2",
"form-0-id": "3",
"form-1-id": "4"}
self.client.get("/assessment/201530/EG500001/happypaper{}/21743148/".format(happypaper.pk))
self.client.get("/assessment/201530/EG500001/writingassignment{}/21743148/".format(writingassignment.pk))
allrubricobjs = RubricData.objects.filter(assignment=writingassignment, enrollment=bobenrollment)
self.assertEqual(allrubricobjs.count(),1)
class ClassViewTest(TestCase):
def add_two_classes_to_semester_add_two_students_to_class(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
self.test_user = User.objects.create_superuser(self.username, self.email, self.password)
login = self.client.login(username=self.username, password = self.password)
jane = User.objects.create(username="******")
first_semester = Semester.objects.create(text='201530')
edClass = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="5000", teacher=self.test_user, crn=2222, semester=first_semester)
edClass2 = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="6000", teacher=self.test_user, crn=3333, semester=first_semester)
edClass1 = EdClasses.objects.create(sectionnumber="01",subject="EG", coursenumber="5111", teacher=jane, crn=4444, semester=first_semester)
#first_semester.classes.add(edClass)
#first_semester.classes.add(edClass2)
#first_semester.classes.add(edClass1)
rubric = Rubric.objects.create(name="bob")
edclasssemester = Assignment.objects.create(edclass=edClass, assignmentname="Writing Assignment",keyrubric=rubric)
edclasssemester1 = Assignment.objects.create(edclass=edClass2, keyrubric=rubric)
edclasssemester2 = Assignment.objects.create(edclass=edClass1, keyrubric=rubric)
#edclasssemester.keyrubric.add(rubric)
#edclasssemester1.keyrubric.add(rubric)
#edclasssemester2.keyrubric.add(rubric)
bob = Student.objects.create(lastname="DaBuilder", firstname="Bob", lnumber="21743148")
jane = Student.objects.create(lastname="Doe", firstname="Jane", lnumber="21743149")
kelly = Student.objects.create(lastname="Smith", firstname="Kelly", lnumber="33333333")
bobenrollment = Enrollment.objects.create(student=bob, edclass=edClass)#, semester=first_semester)
janeenrollment = Enrollment.objects.create(student=jane,edclass=edClass)#, semester=first_semester), semester=first_semester)
bobenrollment2 = Enrollment.objects.create(student=bob,edclass=edClass2)#, semester=first_semester), semester=first_semester)
janeenrollment2 = Enrollment.objects.create(student=jane,edclass=edClass2)#, semester=first_semester), semester=first_semester)
kellyenrollment = Enrollment.objects.create(student=kelly, edclass=edClass1)#, semester=first_semester), semester=first_semester)
def test_user_logs_in(self):
self.client = Client()
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
self.test_user = User.objects.create_user(self.username, self.email, self.password)
login = self.client.login(username=self.username, password = self.password)
self.assertEqual(login, True)
def test_bob_cannot_see_jane_students(self):
self.add_two_classes_to_semester_add_two_students_to_class()
response = self.client.get('/assessment/201530/EG5111/writingassignment1/')
self.assertNotIn("Smith", response.content.decode())
def test_jane_class_results_in_404(self):
#bob is logged in right now. shouldnt see jane class
self.add_two_classes_to_semester_add_two_students_to_class()
response = self.client.get('/assessment/201530/EG5111/writingassignment/1')
self.assertEqual(response.status_code, 404)
def test_semester_page_requires_login(self):
#follow=True follows the redirect to the login page
response = self.client.get("/assessment/201530/", follow=True)
self.assertIn("Username", response.content.decode())
def test_student_page_returns_correct_template(self):
self.add_two_classes_to_semester_add_two_students_to_class()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/")
self.assertTemplateUsed(response, 'rubricapp/student.html')
def test_semester_page_redirects_to_class_url(self):
self.add_two_classes_to_semester_add_two_students_to_class()
request = HttpRequest()
Bob = User.objects.get(username='******')
request.user = Bob
request.method = "POST"
edClass = EdClasses.objects.get(subject="EG", coursenumber="5000", sectionnumber="01")
request.POST['edClass'] = edClass.subject + edClass.coursenumber + edClass.sectionnumber
response = semester_page(request, "201530")
self.assertEqual(response['location'], 'EG500001/')
def test_semester_page_can_show_without_redirecting(self):
#TODO setup semester/class/ url
self.add_two_classes_to_semester_add_two_students_to_class()
assignmentname = Assignment.objects.get(assignmentname="Writing Assignment")
response = self.client.get("/assessment/201530/EG500001/writingassignment{}/".format(assignmentname.pk))
self.assertContains(response, 'Bob DaBuilder')
def test_class_page_can_take_post_request(self):
self.add_two_classes_to_semester_add_two_students_to_class()
request = HttpRequest()
request.method = "POST"
Bob = User.objects.get(username='******')
request.user = Bob
bob = Student.objects.get(lnumber="21743148")
request.POST['studentnames'] = bob.lnumber
assignment= Assignment.objects.get(assignmentname="Writing Assignment")
response = student_page(request, "EG500001", "201530", "Writing Assignment{}".format(assignment.pk))
self.assertEqual(response.status_code, 302)
def test_class_page_redirects_to_student_url(self):
self.add_two_classes_to_semester_add_two_students_to_class()
request = HttpRequest()
request.method = 'POST'
Bob = User.objects.get(username='******')
request.user = Bob
student = Student.objects.get(lnumber="21743148")
request.POST['studentnames'] = student.lnumber
assignment = Assignment.objects.get(assignmentname="Writing Assignment")
response = student_page(request, "EG500001", "201530", "Writing Assignment{}".format(assignment.pk))
self.assertEqual(response.status_code, 302)
self.assertEqual(response['location'], '21743148/')
def test_class_page_shows_url_if_no_students(self):
self.add_two_classes_to_semester_add_two_students_to_class()
bobenrollment = Enrollment.objects.get(student__lastname="DaBuilder", edclass__subject="EG", edclass__coursenumber="5000")
edclass= EdClasses.objects.get(crn=2222)
assignment = Assignment.objects.get(assignmentname="Writing Assignment", edclass=edclass)
bobrubric = RubricData.objects.get_or_create(assignment=assignment, enrollment=bobenrollment)
bobrubric[0].rubriccompleted = True
bobrubric[0].save()
janeenrollment = Enrollment.objects.get(student__lastname="Doe", edclass__subject="EG", edclass__coursenumber="5000")
janerubric = RubricData.objects.get_or_create(assignment=assignment, enrollment=janeenrollment)
janerubric[0].rubriccompleted = True
janerubric[0].save()
response = self.client.get("/assessment/201530/EG500001/writingassignment1/")
self.assertIn("Return to the semester page", response.content.decode())
def test_class_page_does_not_show_students_from_other_semesters(self):
self.add_two_classes_to_semester_add_two_students_to_class()
booritter = Student.objects.create(lastname="Ritter", firstname="Elaine", lnumber="21743142")
newsemester = Semester.objects.create(text="201610")
bob = User.objects.create(username="******")
edclass = EdClasses.objects.create(crn=7777, subject="EG", coursenumber="5001", semester=newsemester, teacher=bob)
#newsemester.classes.add(edclass)
#edclassenrollment = Assignment.objects.create(edclass=edclass)
booenrollment = Enrollment.objects.create(student=booritter, edclass=edclass)#, semester=newsemester)
response = self.client.get('/assessment/201530/EG500001/writingassignment1/')
self.assertNotContains(response, "Elaine")
class BasicTest(TestCase):
fixtures = ['initial_data.json']
password = '******'
username = '******'
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(self.username, '*****@*****.**', \
self.password)
def login(self):
login = self.client.login(username=self.username, \
password=self.password)
self.failUnless(login, 'Could not log in')
def test_index(self):
response = self.client.get(reverse('home'))
p = Person.objects.get(pk=1)
self.failUnlessEqual(response.status_code, 200)
self.assertContains(response, p.name)
self.assertContains(response, p.surname)
self.assertContains(response, p.date)
self.assertContains(response, p.bio)
self.assertContains(response, p.skype)
self.assertContains(response, p.email)
self.assertContains(response, p.jabber)
self.assertContains(response, p.photo.url)
self.assertContains(response, p.contacts)
def test_middleware(self):
count = Location.objects.count()
response = self.client.get(reverse('home'))
self.failUnlessEqual(response.status_code, 200)
self.failUnlessEqual(count + 1, Location.objects.count())
def test_requests(self):
response = self.client.get(reverse('first-requests'))
self.failUnlessEqual(response.status_code, 200)
for i in Location.objects.filter(priority=0)[:10]:
self.assertContains(response, i)
response = self.client.get(reverse('first-requests') + '?priority=1')
self.failUnlessEqual(response.status_code, 200)
for i in Location.objects.filter(priority=1)[:10]:
self.assertContains(response, i)
response = self.client.get(reverse('first-requests') + '?priority=0')
self.failUnlessEqual(response.status_code, 200)
for i in Location.objects.filter(priority=0)[:10]:
self.assertContains(response, i)
def test_context_proccessor(self):
response = self.client.get(reverse('home'))
self.failUnlessEqual(response.status_code, 200)
self.assertContains(response, settings.LANGUAGE_CODE)
def test_edit(self):
# redirect to login-page
response = self.client.get(reverse('edit-profile'))
self.failUnlessEqual(response.status_code, 302)
self.login()
response = self.client.get(reverse('edit-profile'))
self.failUnlessEqual(response.status_code, 200)
def test_save(self):
data = {
'name': 'test_name',
'surname': 'test_surname',
'bio': 'test_bio',
'skype': 'test_skype',
'email': '*****@*****.**',
'jabber': 'test_jabber',
'contacts': 'test_contacts',
'date': '2010-10-10',
}
response = self.client.post(reverse('save-profile'), data)
#redirect to login page
self.failUnlessEqual(response.status_code, 302)
self.login()
response = self.client.get(reverse('save-profile'), data)
# doeant supprt GET method
self.failUnlessEqual(response.status_code, 405)
response = self.client.post(reverse('save-profile'), data)
self.failUnlessEqual(response.status_code, 200)
self.failUnlessEqual(response.content, '{"result": 1}')
p = Person.objects.get(pk=1)
self.failUnlessEqual(data['name'], p.name)
self.failUnlessEqual(data['surname'], p.surname)
self.failUnlessEqual(data['bio'], p.bio)
self.failUnlessEqual(data['skype'], p.skype)
self.failUnlessEqual(data['email'], p.email)
self.failUnlessEqual(data['jabber'], p.jabber)
self.failUnlessEqual(data['date'], str(p.date))
self.failUnlessEqual(data['contacts'], p.contacts)
def test_tag_edit_link(self):
response = Template(
"{% load basic_urls %}{% edit_link user %}").render(
Context({"user": self.user}))
c = self.user.__class__
self.failUnlessEqual(response, reverse('admin:%s_%s_change' % \
(c._meta.app_label, c._meta.module_name), args=[self.user.pk]))
def test_print_models(self):
sys.stdout = open('dump_mycommand.txt', 'w')
call_command('print_models')
sys.stdout.close()
sys.stdout = sys.__stdout__
f = file('dump_mycommand.txt', "r")
result = "Project models:\n%s" % \
"\n".join(["%s - %s" % (m._meta.object_name, m.objects.count())
for m in get_models()])
self.failUnlessEqual(f.read().strip('\n'), result.strip('\n'))
f.close()
os.remove('dump_mycommand.txt')
def test_bash_script(self):
os.system('./print_models')
file = './%s.dat' % date.today().strftime("%Y-%m-%d")
self.failUnlessEqual(
os.path.exists('./%s.dat' % date.today().strftime("%Y-%m-%d")),
True)
os.remove(file)
def test_signals(self):
count = Log.objects.count()
l = Location(name='/')
l.save()
log_count = Log.objects.count()
self.failUnlessEqual(Log.objects.all()[log_count - 1].action, 'create')
self.failUnlessEqual(count + 1, log_count)
l.name = ""
l.save()
log_count = Log.objects.count()
self.failUnlessEqual(Log.objects.all()[log_count - 1].action, 'update')
self.failUnlessEqual(count + 2, log_count)
l.delete()
log_count = Log.objects.count()
self.failUnlessEqual(count + 3, log_count)
self.failUnlessEqual(Log.objects.all()[log_count - 1].action, 'delete')
def static_analysis_test():
"""Test Static Analyzer"""
print("\n[INFO] Running Static Analyzer Unit test")
failed = False
err_msg = '%s'
if platform.system() != "Windows":
err_msg = '\033[91m \033[1m %s \033[0m'
try:
uploaded = []
print("[INFO] Running Upload Test")
http_client = Client()
apk_dir = os.path.join(settings.BASE_DIR, "StaticAnalyzer/test_files/")
for filename in os.listdir(apk_dir):
fpath = os.path.join(apk_dir, filename)
with open(fpath, 'rb') as filp:
response = http_client.post('/upload/', {'file': filp})
obj = json.loads(response.content.decode("utf-8"))
if response.status_code == 200 and obj["status"] == "success":
print("[OK] Upload OK: " + filename)
uploaded.append(obj["url"])
else:
print(err_msg % "[ERROR] Performing Upload: " + filename)
failed = True
print("[OK] Completed Upload test")
print("[INFO] Running Static Analysis Test")
for upl in uploaded:
if RESCAN:
upl = "/" + upl + "&rescan=1"
else:
upl = "/" + upl
resp = http_client.get(upl, follow=True)
if resp.status_code == 200:
print("[OK] Static Analysis Complete: " + upl)
else:
print(err_msg % "[ERROR] Performing Static Analysis: " + upl)
failed = True
print("[OK] Static Analysis test completed")
print("[INFO] Running PDF Generation Test")
if platform.system() in ['Darwin', 'Linux']:
pdfs = [
"/PDF/?md5=3a552566097a8de588b8184b059b0158&type=APK",
"/PDF/?md5=6c23c2970551be15f32bbab0b5db0c71&type=IPA",
"/PDF/?md5=52c50ae824e329ba8b5b7a0f523efffe&type=ANDZIP",
"/PDF/?md5=57bb5be0ea44a755ada4a93885c3825e&type=IOSZIP",
"/PDF/?md5=8179b557433835827a70510584f3143e&type=APPX",
]
else:
pdfs = [
"/PDF/?md5=3a552566097a8de588b8184b059b0158&type=APK",
"/PDF/?md5=52c50ae824e329ba8b5b7a0f523efffe&type=ANDZIP",
"/PDF/?md5=57bb5be0ea44a755ada4a93885c3825e&type=IOSZIP",
"/PDF/?md5=8179b557433835827a70510584f3143e&type=APPX",
]
for pdf in pdfs:
resp = http_client.get(pdf)
if (resp.status_code == 200
and resp._headers['content-type'][1] == "application/pdf"):
print("[OK] PDF Report Generated: " + pdf)
else:
print(err_msg % "[ERROR] Generating PDF: " + pdf)
print(resp.content)
failed = True
print("[OK] PDF Generation test completed")
# Compare apps test
print("[INFO] testing app compare")
first_app = '3a552566097a8de588b8184b059b0158'
second_app = 'f79e40c4c8622c6ebd44679ffbd2f475'
url = '/compare/{}/{}/'.format(first_app, second_app)
resp = http_client.get(url, follow=True)
assert (resp.status_code == 200)
if resp.status_code == 200:
print("[OK] App compare passed Successfully")
else:
print(err_msg % "[ERROR] App compare ")
print(resp.content)
failed = True
print("[INFO] Running Delete Scan Results test")
# Deleting Scan Results
if platform.system() in ['Darwin', 'Linux']:
scan_md5s = [
"3a552566097a8de588b8184b059b0158",
"6c23c2970551be15f32bbab0b5db0c71",
"52c50ae824e329ba8b5b7a0f523efffe",
"57bb5be0ea44a755ada4a93885c3825e",
"8179b557433835827a70510584f3143e",
"f79e40c4c8622c6ebd44679ffbd2f475"
]
else:
scan_md5s = [
"3a552566097a8de588b8184b059b0158",
"52c50ae824e329ba8b5b7a0f523efffe",
"57bb5be0ea44a755ada4a93885c3825e",
"8179b557433835827a70510584f3143e"
]
for md5 in scan_md5s:
resp = http_client.post('/delete_scan/', {'md5': md5})
if resp.status_code == 200:
dat = json.loads(resp.content.decode("utf-8"))
if dat["deleted"] == "yes":
print("[OK] Deleted Scan: " + md5)
else:
print(err_msg % "[ERROR] Deleting Scan: " + md5)
failed = True
else:
print(err_msg % "[ERROR] Deleting Scan: " + md5)
failed = True
print("[INFO] Delete Scan Results test completed")
except:
PrintException("[ERROR] Completing Static Analyzer Test")
return failed
class ReviewTestApi(TestCase):
def setUp(self):
self.superuser = User.objects.create_user(username='******',
email='',
is_superuser=True,
password=TEST_PASSWORD)
self.buyer = User.objects.create_user(username='******',
email='',
is_active=True,
password=TEST_PASSWORD)
self.superclient = APIClient(username='******')
self.superclient.login(username='******', password=TEST_PASSWORD)
self.buyerclient = Client()
self.review_super = Review.objects.create(user=self.superuser,
text='some text')
self.review_buyer = Review.objects.create(user=self.buyer,
text='some text')
def generate_image(self):
image = Image.new('RGB', (100, 100))
tmp_file = tempfile.NamedTemporaryFile(suffix='.png')
image.save(tmp_file)
tmp_file.seek(0)
return tmp_file
def test_get_review_list_superuser_with_permission(self):
response = self.superclient.get('/comments/reviews/')
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(), {
'count':
2,
'next':
None,
'previous':
None,
'results': [{
'user': {
'username': self.superuser.username
},
'product': None,
'text': 'some text',
'created': response.data['results'][0]['created'],
'child': [],
'reply_to': None
}, {
'user': {
'username': self.buyer.username
},
'product': None,
'text': 'some text',
'created': response.data['results'][1]['created'],
'child': [],
'reply_to': None
}]
})
def test_get_review_list_buyer_with_permission(self):
response = self.buyerclient.get('/comments/reviews/')
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(), {
'count':
2,
'next':
None,
'previous':
None,
'results': [{
'user': {
'username': self.buyer.username
},
'product': None,
'text': 'some text',
'created': response.data['results'][0]['created'],
'child': [],
'reply_to': None
}, {
'user': {
'username': self.superuser.username
},
'product': None,
'text': 'some text',
'created': response.data['results'][1]['created'],
'child': [],
'reply_to': None
}]
})
def test_get_detail_review_buyer_with_permission(self):
self.buyerclient.login()
response = self.buyerclient.get(
f'/comments/reviews/{self.review_buyer.id}/')
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(), {
'user': {
'username': self.buyer.username
},
'product': None,
'text': 'some text',
'created': response.data['created'],
'child': [],
'reply_to': None
})
def test_get_detail_review_buyer_without_permission(self):
response = self.buyerclient.get(
f'/comments/reviews/{self.review_buyer.id}/')
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(), {
'user': {
'username': self.buyer.username
},
'product': None,
'text': 'some text',
'created': response.data['created'],
'child': [],
'reply_to': None
})
def test_post_review_list_superuser_with_permission(self):
response = self.superclient.post('/comments/reviews/', {
'product': '',
'text': 'lalala',
'child': []
})
self.assertEqual(response.status_code, 201)
self.assertEqual(
response.json(), {
'child': [],
'created': response.data['created'],
'product': None,
'reply_to': None,
'text': 'lalala',
'user': {
'username': '******'
}
})
def test_post_review_list_buyer_with_permission(self):
self.buyerclient.login(username='******', password=TEST_PASSWORD)
response = self.buyerclient.post('/comments/reviews/', {
'product': '',
'text': 'dadadad',
'child': []
})
self.assertEqual(response.status_code, 201)
self.assertEqual(
response.json(), {
'child': [],
'created': response.data['created'],
'product': None,
'reply_to': None,
'text': 'dadadad',
'user': {
'username': '******'
}
})
def test_post_review_list_buyer_without_permission(self):
response = self.buyerclient.post('/comments/reviews/', {
'product': '',
'text': 'dadadad',
'child': []
})
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{'detail': 'Authentication credentials were not provided.'})
def test_post_image_buyer_with_permission(self):
self.buyerclient.login(username='******', password=TEST_PASSWORD)
response = self.buyerclient.post('/comments/reviews-image/', {
'raw_photo': self.generate_image(),
'review': self.review_buyer.id
},
format='multipart')
self.assertEqual(response.status_code, 201)
def test_get_apply_club_list_not_logged_in(self):
client = Client(enforce_csrf_checks=False)
response = client.get('/api/user/1/club/apply/')
self.assertEqual(response.status_code, 401)
class InstitutionViewTest(unittest.TestCase):
'''
Tests for Institution
'''
def setUp(self):
self.client = Client()
def test_list_institution(self):
url = reverse('institution_list')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_create_institution(self):
url = reverse('institution_create')
data = {
"InstitutionName":
"InstitutionName",
"InstitutionEmail":
"InstitutionEmail",
"InstitutionPhone":
"InstitutionPhone",
"InstitutionWebsite":
"InstitutionWebsite",
"InstitutionAddressStreet":
"InstitutionAddressStreet",
"InstitutionNote":
"InstitutionNote",
"InstitutionAddressVDCMunicipality":
create_addressvdcmunicipality().pk,
}
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 302)
def test_detail_institution(self):
institution = create_institution()
url = reverse('institution_detail', args=[
institution.pk,
])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_update_institution(self):
institution = create_institution()
data = {
"InstitutionName":
"InstitutionName",
"InstitutionEmail":
"InstitutionEmail",
"InstitutionPhone":
"InstitutionPhone",
"InstitutionWebsite":
"InstitutionWebsite",
"InstitutionAddressStreet":
"InstitutionAddressStreet",
"InstitutionNote":
"InstitutionNote",
"InstitutionAddressVDCMunicipality":
create_addressvdcmunicipality().pk,
}
url = reverse('institution_update', args=[
institution.pk,
])
response = self.client.post(url, data)
self.assertEqual(response.status_code, 302)
def test_get_club_by_id_not_found(self):
client = Client(enforce_csrf_checks=False)
response = client.get('/api/club/10/')
self.assertEqual(response.status_code, 404)
class TarDownloadTestCase(TestCase):
def setUp(self):
# create user
self.testuser = User(username='******')
self.testuser.save()
# create test experiment
self.exp = Experiment(title='tar download test' * 15,
created_by=self.testuser,
public_access=Experiment.PUBLIC_ACCESS_FULL)
self.exp.save()
# create test dataset
self.ds = self.exp.datasets.create(
description="testing tar download dataset")
datafile_content = "\n".join(['some data %d' % i for i in range(1000)])
filesize = len(datafile_content)
md5sum = hashlib.md5(datafile_content).hexdigest()
# create test datafiles and datafile objects
self.dfs = []
for i in range(20):
df = self.ds.datafile_set.create(
filename='testfile%d.txt' % i,
mimetype='text/plain',
size=filesize,
md5sum=md5sum,
directory='/'.join(['testdir%d' % i for i in range(i, i + 4)]))
df.file_object = StringIO(datafile_content)
df.refresh_from_db()
self.dfs.append(df)
# mock client
self.client = Client()
def tearDown(self):
# delete created objects and files
[ds.delete() for ds in self.exp.datasets.all()]
self.exp.delete()
def test_tar_experiment_download(self):
self.assertTrue(all(df.verified for df in self.dfs))
response = self.client.get(
reverse(
'tardis.tardis_portal.download.streaming_download_experiment',
args=(self.exp.id, 'tar')))
with NamedTemporaryFile('w') as tarfile:
for c in response.streaming_content:
tarfile.write(c)
tarfile.flush()
self.assertEqual(int(response['Content-Length']),
os.stat(tarfile.name).st_size)
tf = TarFile(tarfile.name)
for df in self.dfs:
full_path = os.path.join(self.exp.title.replace(' ', '_'),
quote(self.ds.description, safe=''),
df.directory, df.filename)
# docker has a file path limit of ~240 characters
if os.environ.get('DOCKER_BUILD', 'false') != 'true':
tf.extract(full_path, '/tmp')
self.assertEqual(
os.stat(os.path.join('/tmp', full_path)).st_size,
int(df.size))
class MemberViewTest(unittest.TestCase):
'''
Tests for Member
'''
def setUp(self):
self.client = Client()
def test_list_member(self):
url = reverse('member_list')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_create_member(self):
url = reverse('member_create')
data = {
"MemberRegistrationID": "MemberRegistrationID",
"MemberName": "MemberName",
"MemberGender": "MemberGender",
"MemberBirthDate": "MemberBirthDate",
"MemberFatherName": "MemberFatherName",
"MemberPhone": "MemberPhone",
"MemberVerified": "MemberVerified",
"MemberRegisterDateTime": "MemberRegisterDateTime",
"MemberRegisterAgent": "MemberRegisterAgent",
"MemberNote": "MemberNote",
"MemberStreetTemporaryAddress": "MemberStreetTemporaryAddress",
"MemberStreetPermanentAddress": "MemberStreetPermanentAddress",
"MemberPermanentAddress": create_addressvdcmunicipality().pk,
"MemberTemporaryAddress": create_addressvdcmunicipality().pk,
"MemberInstitution": create_institution().pk,
}
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 302)
def test_detail_member(self):
member = create_member()
url = reverse('member_detail', args=[
member.pk,
])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_update_member(self):
member = create_member()
data = {
"MemberRegistrationID": "MemberRegistrationID",
"MemberName": "MemberName",
"MemberGender": "MemberGender",
"MemberBirthDate": "MemberBirthDate",
"MemberFatherName": "MemberFatherName",
"MemberPhone": "MemberPhone",
"MemberVerified": "MemberVerified",
"MemberRegisterDateTime": "MemberRegisterDateTime",
"MemberRegisterAgent": "MemberRegisterAgent",
"MemberNote": "MemberNote",
"MemberStreetTemporaryAddress": "MemberStreetTemporaryAddress",
"MemberStreetPermanentAddress": "MemberStreetPermanentAddress",
"MemberPermanentAddress": create_addressvdcmunicipality().pk,
"MemberTemporaryAddress": create_addressvdcmunicipality().pk,
"MemberInstitution": create_institution().pk,
}
url = reverse('member_update', args=[
member.pk,
])
response = self.client.post(url, data)
self.assertEqual(response.status_code, 302)
class ModuleTestCase(TestCase):
def setUp(self):
User.objects.create_user("Linda01", "*****@*****.**",
"Linda01123456")
Project.objects.create(name="项目Test1", description="描述Test1")
project = Project.objects.get(name="项目Test1")
Module.objects.create(project=project,
name="模块Test1",
description="这里是模块Test1的描述")
self.client = Client()
self.client.post("/login_action/", {
"username": "******",
"password": "******"
})
# 测试模块列表
def test_module_manage(self):
response = self.client.get("/manage/module_manage/")
response_content_html = response.content.decode("utf-8")
self.assertEquals(response.status_code, 200)
self.assertIn("模块Test1", response_content_html)
# 测试模块查询
def test_search_module(self):
# 查询关键字不为空
response = self.client.get("/manage/search_module/",
{"keyword": "Test1"})
self.assertEquals(response.status_code, 200)
self.assertIn("模块Test1", response.content.decode("utf-8"))
# 查询关键字为空
response = self.client.get("/manage/search_module/", {"keyword": ""})
self.assertRedirects(response, "/manage/module_manage/")
# 测试新增模块
def test_add_project(self):
# 测试get请求
response = self.client.get("/manage/add_module/")
self.assertEquals(response.status_code, 200)
self.assertIn("新增模块", response.content.decode("utf-8"))
# 测试post请求(有效参数）
response = self.client.post("/manage/add_module/", {
"name": "模块Test2",
"description": "模块Test2的描述",
"project": 1
})
self.assertEquals(response.status_code, 302)
self.assertEquals(len(Module.objects.filter(name__contains="模块Test2")),
1)
# 测试post请求(无效参数）
self.client.post("/manage/add_module/", {
"name": "",
"description": "",
"project": 1
})
self.assertEquals(len(Module.objects.all()), 2)
# 测试删除模块
def test_delete_module(self):
response = self.client.get("/manage/delete_module/1/")
self.assertEquals(response.status_code, 302)
self.assertEquals(len(Module.objects.filter(name__contains="模块Test1")),
0)
# 测试编辑模块
def test_edit_project(self):
# 测试get请求
response = self.client.get("/manage/edit_module/1/")
self.assertEquals(response.status_code, 200)
self.assertIn("模块Test1", response.content.decode("utf-8"))
# 测试post请求
response = self.client.post("/manage/edit_module/1/", {
"name": "模块Test2(修改后）",
"description": "模块Test2的描述(修改后)",
"project": 1
})
self.assertEquals(response.status_code, 302)
module = Module.objects.get(name="模块Test2(修改后）")
self.assertEquals(module.description, "模块Test2的描述(修改后)")
class AddressViewSetTest(TestCase):
def setUp(self):
self.client = Client()
def test_create_address(self):
seller1 = mommy.make('sellgood.Seller')
data = {
'street': 'Main Street',
'neighborhood': 'Northern Brooklyn',
'city': 'New York',
'state': 'New York',
'number': '5214',
'complement': 'Apartment 204',
'zipcode': '10001',
'seller': 1
}
response = self.client.post(reverse(
'sellgood:address-list'), data=json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.json()['state'], 'New York')
self.assertEqual(response.json()['seller'], 1)
def test_empty_address(self):
response = self.client.get(reverse('sellgood:address-list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 0)
def test_method_not_allowed_list(self):
put_response = self.client.put(reverse('sellgood:address-list'))
delete_response = self.client.delete(reverse('sellgood:address-list'))
self.assertEqual(put_response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
self.assertEqual(delete_response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_number_address_recorded(self):
address1 = mommy.make('sellgood.Address',
seller=mommy.make('sellgood.Seller'))
address2 = mommy.make('sellgood.Address',
seller=mommy.make('sellgood.Seller'))
response = self.client.get(reverse('sellgood:address-list'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 2)
def test_detail_address(self):
address1 = mommy.make(
'sellgood.Address', city='Arkham', street='Main Street',
seller=mommy.make('sellgood.Seller'))
response = self.client.get(reverse('sellgood:address-detail',
kwargs={'pk': 1}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['city'], 'Arkham')
self.assertEqual(response.json()['street'], 'Main Street')
def test_update_address(self):
address1 = mommy.make(
'sellgood.Address', city='New York', state='New York',
seller=mommy.make('sellgood.Seller'))
seller2 = mommy.make('sellgood.Seller')
data = {
'street': 'Main Street',
'neighborhood': 'Northern Brooklyn',
'city': 'Arkham',
'state': 'New Jersey',
'number': '666',
'complement': 'Apartment 25',
'zipcode': '10009',
'seller': 2
}
response = self.client.put(reverse(
'sellgood:address-detail', kwargs={'pk': 1}),
data=json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['city'], 'Arkham')
self.assertEqual(response.json()['state'], 'New Jersey')
self.assertEqual(response.json()['zipcode'], '10009')
self.assertEqual(response.json()['seller'], 2)
response2 = self.client.get(reverse('sellgood:address-detail',
kwargs={'pk': 2}))
def test_partially_update_seller(self):
address = mommy.make('Address')
data = {'id': address.seller.id,
'street': 'nowhere'}
response = self.client.patch(reverse('sellgood:address-detail', kwargs={'pk': address.seller.id}),
data=data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['street'], 'nowhere')
def test_delete_address(self):
address1 = mommy.make('sellgood.Address',
seller=mommy.make('sellgood.Seller'))
response = self.client.delete(reverse(
'sellgood:address-detail', kwargs={'pk': 1}))
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_address_to_delete_not_found(self):
address1 = mommy.make('sellgood.Address',
seller=mommy.make('sellgood.Seller'))
response = self.client.delete(reverse('sellgood:address-detail',
kwargs={'pk': 2}))
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_method_not_allowed_detail(self):
address1 = mommy.make('sellgood.Address',
seller=mommy.make('sellgood.Seller'))
response = self.client.post(reverse('sellgood:address-detail',
kwargs={'pk': 1}))
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
class ViewsTestCase(TestCase):
NAME = "TEST USER"
EMAIL = "*****@*****.**"
META = "TEST USER META"
BASIC_URL = "authorization"
ID_DATA_VALUE = "ID DATA VALUE"
URLS = [
"create_user", "change_settings",
"post_data", "validate_user", "match_data"
]
def setUp(self):
self.client = Client()
def create_url(self, url_part):
return "http://localhost:8000/" + self.BASIC_URL + "/" + url_part
def test_create_user(self):
response = self.client.post(
self.create_url(self.URLS[0]),
{'name': self.NAME, 'email': self.EMAIL, 'meta': self.META}
)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(
response_data["status"], "success"
)
def test_change_settings(self):
test_case = "CHANGE"
response = self.client.post(
self.create_url(self.URLS[0]),
{'name': self.NAME, 'email': self.EMAIL, 'meta': self.META}
)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(
response_data["status"], "success"
)
response_data.pop("status")
response_new = self.client.post(
self.create_url(self.URLS[1]),
{
**response_data,
'name': self.NAME + test_case,
'email': self.EMAIL + test_case,
'meta': self.META + test_case,
}
)
self.assertEqual(response_new.status_code, 200)
response_new_data = json.loads(response_new.content.decode("utf-8"))
self.assertEqual(
response_new_data["status"], "success"
)
def test_post_data(self):
test_case = "POST DATA"
response = self.client.post(
self.create_url(self.URLS[0]),
{'name': self.NAME, 'email': self.EMAIL, 'meta': self.META}
)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(
response_data["status"], "success"
)
response_data.pop("status")
response_new = self.client.post(
self.create_url(self.URLS[2]),
{
**response_data,
"id_data_value": self.ID_DATA_VALUE + "VIEW",
"data_type": "test_data",
"timestamp": 0,
}
)
self.assertEqual(response_new.status_code, 200)
response_new_data = json.loads(response_new.content.decode("utf-8"))
self.assertEqual(
response_new_data["status"], "success"
)
def test_validate_user(self):
response = self.client.post(
self.create_url(self.URLS[0]),
{'name': self.NAME, 'email': self.EMAIL, 'meta': self.META}
)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(
response_data["status"], "success"
)
response_data.pop("status")
response_new = self.client.get(
self.create_url(self.URLS[3]),
{
**response_data,
}
)
self.assertEqual(response_new.status_code, 200)
response_new_data = json.loads(response_new.content.decode("utf-8"))
self.assertEqual(
response_new_data["status"], "success"
)
def test_match(self):
test_case = "POST DATA"
# Post user 1
response = self.client.post(
self.create_url(self.URLS[0]),
{'name': self.NAME + "1", 'email': self.EMAIL, 'meta': self.META}
)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(
response_data["status"], "success"
)
response_data.pop("status")
response_new = self.client.post(
self.create_url(self.URLS[2]),
{
**response_data,
"id_data_value": self.ID_DATA_VALUE + "VIEW 1",
"data_type": "test_data",
"timestamp": 0,
}
)
self.assertEqual(response_new.status_code, 200)
response_new_data = json.loads(response_new.content.decode("utf-8"))
self.assertEqual(
response_new_data["status"], "success"
)
# Post user 2
response = self.client.post(
self.create_url(self.URLS[0]),
{'name': self.NAME + "2", 'email': self.EMAIL, 'meta': self.META}
)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(
response_data["status"], "success"
)
response_data.pop("status")
response_new = self.client.post(
self.create_url(self.URLS[2]),
{
**response_data,
"id_data_value": self.ID_DATA_VALUE + "VIEW ",
"data_type": "test_data",
"timestamp": 0,
}
)
self.assertEqual(response_new.status_code, 200)
response_new_data = json.loads(response_new.content.decode("utf-8"))
self.assertEqual(
response_new_data["status"], "success"
)
response_match = self.client.get(
self.create_url(self.URLS[4]),
{**response_data}
)
response_match_data = json.loads(
response_match.content.decode("utf-8")
)
self.assertNotEqual(
self.ID_DATA_VALUE + "VIEW ", response_match_data["id_data_value"]
)
class BulkArchiveForms(TestCase):
@classmethod
def setUpClass(cls):
super(BulkArchiveForms, cls).setUpClass()
create_domain(DOMAIN_NAME)
cls.password = "******"
username = "******"
email = "*****@*****.**"
cls.user = WebUser.create(DOMAIN_NAME,
username,
cls.password,
email,
is_admin=True)
django_user = cls.user.get_django_user()
try:
cls.user_role = UserRole.objects.get(user=django_user)
except UserRole.DoesNotExist:
user_privs = Role.objects.get_or_create(
name="Privileges for %s" % django_user.username,
slug="%s_privileges" % django_user.username,
)[0]
cls.user_role = UserRole.objects.create(
user=django_user,
role=user_privs,
)
cls.bulk_role = Role.objects.filter(
slug=privileges.BULK_CASE_MANAGEMENT)[0]
toggles.BULK_ARCHIVE_FORMS.set(username, True)
@classmethod
def tearDownClass(cls):
cls.user.delete()
Domain.get_by_name(DOMAIN_NAME, strict=True).delete()
toggles.BULK_ARCHIVE_FORMS.set(cls.user.username, False)
super(BulkArchiveForms, cls).tearDownClass()
def setUp(self):
self.client = Client()
self.url = '/a/{}/data/edit/archive_forms/'.format(DOMAIN_NAME)
Grant.objects.get_or_create(from_role=self.user_role.role,
to_role=self.bulk_role)
Role.get_cache().clear()
self.client.login(username=self.user.username, password=self.password)
def test_bulk_archive_get_form(self):
# Logged in
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.context['bulk_upload']['download_url'],
'/static/data_interfaces/xlsx/forms_bulk_example.xlsx')
grant = Grant.objects.get(from_role=self.user_role.role,
to_role=self.bulk_role)
grant.delete()
Role.get_cache().clear()
# Revoked privileges should not render form
response = self.client.get(self.url)
self.assertFalse('bulk_upload' in response.context)
def test_bulk_archive_missing_file(self):
response = self.client.post(self.url, follow=True)
# Huge hack for determining what has been sent in django messages object.
# Need to find out how to inspect messages after redirect
self.assertIn('No files uploaded', response.content)
def test_bulk_archive_wrong_filetype(self):
with open(join(BASE_PATH, WRONG_FILETYPE)) as fp:
response = self.client.post(self.url, {'bulk_upload_file': fp},
follow=True)
self.assertIn('CommCare HQ does not support that file type.',
response.content)
def test_bulk_archive_basic(self):
with open(join(BASE_PATH, BASIC_XLSX)) as fp:
response = self.client.post(self.url, {'bulk_upload_file': fp},
follow=True)
self.assertIn('We received your file and are processing it.',
response.content)
def test_activation_complete(self):
"""Test successful activation complete."""
c = Client()
response = c.get('/accounts/activate/complete/')
self.assertEqual(response.status_code, 200)
class TestView(TestCase):
def setUp(self):
self.client = Client()
self.user_trump = User.objects.create_user(
username="******", password="******"
)
self.user_obama = User.objects.create_user(
username="******", password="******"
)
self.user_obama.is_staff = True
self.user_obama.save()
self.category_programming = Category.objects.create(
name="programming", slug="programming"
)
self.category_music = Category.objects.create(name="music", slug="music")
self.tag_python_kor = Tag.objects.create(name="파이썬 공부", slug="파이썬-공부")
self.tag_python = Tag.objects.create(name="python", slug="python")
self.tag_hello = Tag.objects.create(name="hello", slug="hello")
self.post_001 = Post.objects.create(
title="첫 번째 포스트입니다.",
content="Hello World. We are the world.",
category=self.category_programming,
author=self.user_trump,
)
self.post_001.tags.add(self.tag_hello)
self.post_002 = Post.objects.create(
title="두 번째 포스트입니다.",
content="1등이 전부는 아니잖아요?",
category=self.category_music,
author=self.user_obama,
)
self.post_003 = Post.objects.create(
title="세 번째 포스트입니다.",
content="category가 없을 수도 있죠",
author=self.user_obama,
)
self.post_003.tags.add(self.tag_python_kor)
self.post_003.tags.add(self.tag_python)
self.comment_001 = Comment.objects.create(
post=self.post_001,
author=self.user_obama,
content="첫 번째 댓글입니다.",
)
def navbar_test(self, soup):
navbar = soup.nav
self.assertIn("Blog", navbar.text)
self.assertIn("About Me", navbar.text)
logo_btn = navbar.find("a", text="Do It Django")
self.assertEqual(logo_btn.attrs["href"], "/")
home_btn = navbar.find("a", text="Home")
self.assertEqual(home_btn.attrs["href"], "/")
blog_btn = navbar.find("a", text="Blog")
self.assertEqual(blog_btn.attrs["href"], "/blog/")
about_me_btn = navbar.find("a", text="About Me")
self.assertEqual(about_me_btn.attrs["href"], "/about_me/")
def category_card_test(self, soup):
categories_card = soup.find("div", id="categories-card")
self.assertIn("Categories", categories_card.text)
self.assertIn(
f"{self.category_programming.name} ({self.category_programming.post_set.count()})",
categories_card.text,
)
self.assertIn(
f"{self.category_music.name} ({self.category_music.post_set.count()})",
categories_card.text,
)
self.assertIn("미분류", categories_card.text)
def test_post_list(self):
# Post가 있는 경우
self.assertEqual(Post.objects.count(), 3)
response = self.client.get("/blog/")
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content, "html.parser")
self.assertEqual(soup.title.text, "Blog - Do It Django")
self.navbar_test(soup)
self.category_card_test(soup)
main_area = soup.find("div", id="main-area")
self.assertNotIn("아직 게시물이 없습니다", main_area.text)
post_001_card = main_area.find("div", id="post-1") # id가 post-1인 div를 찾아서, 그 안에
self.assertIn(self.post_001.title, post_001_card.text) # title이 있는지
self.assertIn(self.post_001.category.name, post_001_card.text) # category가 있는지
self.assertIn(
self.post_001.author.username.capitalize(), post_001_card.text
) # 작성자명이 있는지
self.assertIn(self.tag_hello.name, post_001_card.text)
self.assertNotIn(self.tag_python.name, post_001_card.text)
self.assertNotIn(self.tag_python_kor.name, post_001_card.text)
post_002_card = main_area.find("div", id="post-2")
self.assertIn(self.post_002.title, post_002_card.text)
self.assertIn(self.post_002.category.name, post_002_card.text)
self.assertIn(self.post_002.author.username.capitalize(), post_002_card.text)
self.assertNotIn(self.tag_hello.name, post_002_card.text)
self.assertNotIn(self.tag_python.name, post_002_card.text)
self.assertNotIn(self.tag_python_kor.name, post_002_card.text)
post_003_card = main_area.find("div", id="post-3")
self.assertIn("미분류", post_003_card.text)
self.assertIn(self.post_003.title, post_003_card.text)
self.assertIn(self.post_003.author.username.capitalize(), post_003_card.text)
self.assertNotIn(self.tag_hello.name, post_003_card.text)
self.assertIn(self.tag_python.name, post_003_card.text)
self.assertIn(self.tag_python_kor.name, post_003_card.text)
# Post가 없는 경우
Post.objects.all().delete()
self.assertEqual(Post.objects.count(), 0)
response = self.client.get("/blog/")
soup = BeautifulSoup(response.content, "html.parser")
main_area = soup.find("div", id="main-area") # id가 main-area인 div태그를 찾습니다.
self.assertIn("아직 게시물이 없습니다", main_area.text)
def test_post_detail(self):
# 1.1 포스트가 하나 있다.
post_001 = Post.objects.create(
title="첫 번째 포스트입니다.",
content="Hello World. We are the world.",
author=self.user_trump,
)
# 1.2 그 포스트의 url은 '/blog/1/' 이다.
self.assertEqual(self.post_001.get_absolute_url(), "/blog/1/")
# 2. 첫 번째 포스트의 상세 페이지 테스트
# 2.1 첫 번째 포스트의 url로 접근하면 정상적으로 작동한다.(status code: 200)
response = self.client.get(self.post_001.get_absolute_url())
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content, "html.parser")
# 2.2 포스트 목록 페이지와 똑같은 내비게이션 바가 있다.
# navbar = soup.nav
# self.assertIn("Blog", navbar.text)
# self.assertIn("About Me", navbar.text)
self.navbar_test(soup)
self.category_card_test(soup)
# 2.3 첫 번째 포스트의 제목이 웹 브라우저 탭 타이틀에 들어 있다.
self.assertIn(self.post_001.title, soup.title.text)
# 2.4 첫 번째 포스트의 제목이 포스트 영역에 있다.
main_area = soup.find("div", id="main-area")
post_area = main_area.find("div", id="post-area")
self.assertIn(self.post_001.title, post_area.text)
self.assertIn(self.category_programming.name, post_area.text)
# 2.5 첫 번째 포스트의 작성자(author)가 포스트 영역에 있다.(아직 구현할 수 없음)
self.assertIn(self.user_trump.username.capitalize(), post_area.text)
# 2.6 첫 번째 포스트의 내용(content)이 포스트 영역에 있다.
self.assertIn(self.post_001.content, post_area.text)
self.assertIn(self.tag_hello.name, post_area.text)
self.assertNotIn(self.tag_python.name, post_area.text)
self.assertNotIn(self.tag_python_kor.name, post_area.text)
# comment area
comments_area = soup.find("div", id="comment-area")
comment_001_area = comments_area.find("div", id="comment-1")
self.assertIn(self.comment_001.author.username, comment_001_area.text)
self.assertIn(self.comment_001.content, comment_001_area.text)
def test_category_page(self):
response = self.client.get(self.category_programming.get_absolute_url())
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content, "html.parser")
self.navbar_test(soup)
self.category_card_test(soup)
self.assertIn(self.category_programming.name, soup.h1.text)
main_area = soup.find("div", id="main-area")
self.assertIn(self.category_programming.name, main_area.text)
self.assertIn(self.post_001.title, main_area.text)
self.assertNotIn(self.post_002.title, main_area.text)
self.assertNotIn(self.post_003.title, main_area.text)
def test_tag_page(self):
response = self.client.get(self.tag_hello.get_absolute_url())
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content, "html.parser")
self.navbar_test(soup)
self.category_card_test(soup)
self.assertIn(self.tag_hello.name, soup.h1.text)
main_area = soup.find("div", id="main-area")
self.assertIn(self.tag_hello.name, main_area.text)
self.assertIn(self.post_001.title, main_area.text)
self.assertNotIn(self.post_002.title, main_area.text)
self.assertNotIn(self.post_003.title, main_area.text)
def test_create_post(self):
# 로그인 하지 않으면 status code가 200이면 안된다!
response = self.client.get("/blog/create_post/")
self.assertNotEqual(response.status_code, 200)
# staff가 아닌 trump가 로그인을 한다.
self.client.login(username="******", password="******")
response = self.client.get("/blog/create_post/")
self.assertNotEqual(response.status_code, 200)
# staff인 obama로 로그인한다.
self.client.login(username="******", password="******")
response = self.client.get("/blog/create_post/")
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content, "html.parser")
self.assertEqual("Blog - Create Post", soup.title.text)
main_area = soup.find("div", id="main-area")
self.assertIn("Create New Post", main_area.text)
tag_str_input = main_area.find("input", id="id_tags_str")
self.assertTrue(tag_str_input)
self.client.post(
"/blog/create_post/",
{
"title": "Post Form 만들기",
"content": "Post Form 페이지를 만듭시다.",
"tags_str": "new tag; 한글 태그, python",
},
)
last_post = Post.objects.last()
self.assertEqual(last_post.title, "Post Form 만들기")
self.assertEqual(last_post.author.username, "obama")
self.assertEqual(last_post.tags.count(), 3)
self.assertTrue(Tag.objects.get(name="new tag"))
self.assertTrue(Tag.objects.get(name="한글 태그"))
self.assertEqual(Tag.objects.count(), 5)
def test_update_post(self):
update_post_url = f"/blog/update_post/{self.post_003.pk}/"
# 로그인 하지 않은 경우
response = self.client.get(update_post_url)
self.assertNotEqual(response.status_code, 200)
# 로그인은 했지만, 작성자가 아닌 경우
self.assertNotEqual(self.post_003.author, self.user_trump)
self.client.login(username=self.user_trump.username, password="******")
response = self.client.get(update_post_url)
self.assertEqual(response.status_code, 403)
# 작성자(obama)가 접근하는 경우
self.client.login(
username=self.post_003.author.username, password="******"
)
response = self.client.get(update_post_url)
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content, "html.parser")
self.assertEqual("Blog - Edit Post", soup.title.text)
main_area = soup.find("div", id="main-area")
self.assertIn("Edit Post", main_area.text)
tag_str_input = main_area.find("input", id="id_tags_str")
self.assertTrue(tag_str_input)
self.assertIn("파이썬 공부; python", tag_str_input.attrs["value"])
response = self.client.post(
update_post_url,
{
"title": "세번째 포스트를 수정했습니다. ",
"content": "안녕 세계? 우리는 하나!",
"category": self.category_music.pk,
"tags_str": "파이썬 공부; 한글 태그, some tag",
},
follow=True,
)
soup = BeautifulSoup(response.content, "html.parser")
main_area = soup.find("div", id="main-area")
self.assertIn("세번째 포스트를 수정했습니다.", main_area.text)
self.assertIn("안녕 세계? 우리는 하나!", main_area.text)
self.assertIn(self.category_music.name, main_area.text)
self.assertIn("파이썬 공부", main_area.text)
self.assertIn("한글 태그", main_area.text)
self.assertIn("some tag", main_area.text)
self.assertNotIn("python", main_area.text)
def test_successful_account_signup(self):
"""Test successful signup."""
c = Client()
response = c.get('/accounts/register/')
self.assertEqual(response.status_code, 200)
class TestAuthorView(TestCase):
def setUp(self):
self.client = Client()
# create test user
displayName = 'test author'
host = settings.HEROKU_HOST
github = 'https://github.com/test_author'
username = '******'
password = '******'
# author a
self.a = Author(displayName=displayName ,host=host, github=github, username=username, password=make_password(password))
self.a.url = f'{host}author/{self.a.id}'
self.a.save()
# get token
self.login_url = reverse('login')
response = self.client.post(
self.login_url,
{'username': username, 'password': password},
content_type="application/json",
)
self.token = response.data['token']
self.headers = {
'HTTP_AUTHORIZATION': f'Bearer {self.token}',
'HTTP_ORIGIN': settings.FRONTEND_HOST,
}
# author b
self.b = Author(displayName=displayName ,host=host, github=github, username=username+'b', password=make_password(password))
self.b.url = f'{host}author/{self.b.id}'
self.b.save()
def test_author_api_GET(self):
# get none exist author
self.headers['HTTP_X_URL'] = settings.HEROKU_HOST + 'author/none_exist_author_id'
response = self.client.get(reverse('author-profile', args=['none_exist_author_id']), **self.headers)
self.assertEquals(response.status_code, 404)
# get exist author
response = self.client.get(reverse('author-profile', args=[self.a.id]), **self.headers)
self.assertEquals(response.status_code, 200)
self.assertEquals(response.json()['type'], 'author')
self.assertEquals(response.json()['id'], self.a.url)
self.assertEquals(response.json()['host'], self.a.host)
self.assertEquals(response.json()['displayName'], self.a.displayName)
self.assertEquals(response.json()['url'], self.a.url)
self.assertEquals(response.json()['github'], self.a.github)
def test_author_api_POST(self):
# post to none exist author
self.headers['HTTP_X_URL'] = settings.HEROKU_HOST + 'author/none_exist_author_id'
response = self.client.post(reverse('author-profile', args=['none_exist_author_id']), **self.headers)
self.assertEquals(response.status_code, 404)
# post to exist author
data = {
'id': self.a.url,
'host': self.a.host,
'displayName': 'new name',
'url': self.a.url,
'github': 'https://github.com/new_github',
}
response = self.client.post(
reverse('author-profile', args=[self.a.id]),
data=data,
content_type="application/json",
**self.headers)
self.assertEquals(response.status_code, 200)
self.assertEquals(response.json()['displayName'], 'new name')
self.assertEquals(response.json()['github'], 'https://github.com/new_github')
# post to other exist author
response = self.client.post(
reverse('author-profile', args=[self.b.id]),
data=data,
content_type="application/json",
**self.headers)
self.assertEquals(response.status_code, 403)
def test_author_api_not_allowed_method(self):
# delete exist author
response = self.client.delete(
reverse('author-profile', args=[self.a.id]),
**self.headers)
self.assertEquals(response.status_code, 405)
# put exist author
data = {
'id': self.a.url,
'host': self.a.host,
'displayName': 'new name',
'url': self.a.url,
'github': 'https://github.com/new_github',
}
response = self.client.put(
reverse('author-profile', args=[self.a.id]),
data=data,
content_type="application/json",
**self.headers)
self.assertEquals(response.status_code, 405)
def test_admin_view(self):
"""Tests successful retrieval of admin view."""
c = Client()
reponse = c.get('/admin/login/?next=/admin/')
self.assertEqual(reponse.status_code, 200)
def test_registration_complete(self):
"""Test successful registration."""
c = Client()
response = c.get('/accounts/register/complete/')
self.assertEqual(response.status_code, 200)
class ViewPageContextTest(TestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
os.mkdir(f'{settings.BASE_DIR}/tmp/')
settings.MEDIA_ROOT = tempfile.mkdtemp(dir=f'{settings.BASE_DIR}/tmp/')
def setUp(self):
self.guest_client = Client()
self.user_one = User.objects.create_user(username='******')
self.user_one_client = Client()
self.user_one_client.force_login(self.user_one)
self.user_two = User.objects.create_user(username='******')
self.user_two_client = Client()
self.user_two_client.force_login(self.user_two)
self.test_group = Group.objects.create(
title='Test Group',
slug='group',
description='Description',
)
self.test_second_group = Group.objects.create(
title='Test Second Group',
slug='second-group',
description='Description',
)
self.small_gif = (b'\x47\x49\x46\x38\x39\x61\x02\x00'
b'\x01\x00\x80\x00\x00\x00\x00\x00'
b'\xFF\xFF\xFF\x21\xF9\x04\x00\x00'
b'\x00\x00\x00\x2C\x00\x00\x00\x00'
b'\x02\x00\x01\x00\x00\x02\x02\x0C'
b'\x0A\x00\x3B')
self.uploaded = SimpleUploadedFile(
name='small.gif',
content=self.small_gif,
content_type='image/gif',
)
self.test_post = Post.objects.create(
text='Test post',
author=self.user_one,
group=self.test_group,
image=self.uploaded,
)
cache.clear()
@classmethod
def tearDownClass(cls):
shutil.rmtree(f'{settings.BASE_DIR}/tmp/', ignore_errors=True)
super().tearDownClass()
def test_auth_user_can_follow_unfollow(self):
"""Пользователь может подписаться и отписаться от автора."""
urls = {
reverse('profile_follow', args=[self.user_two]): True,
reverse('profile_unfollow', args=[self.user_two]): False,
}
for url, expected in urls.items():
with self.subTest(url=url):
self.user_one_client.get(url)
actual = Follow.objects.filter(user=self.user_one,
author=self.user_two).exists()
msg = f'{url}: подписка/отписка работает неправильно'
self.assertEqual(actual, expected, msg)
def test_new_post_exist_for_followers(self):
"""Новый пост пользователя появляется у тех кто на него подписан."""
test_post_user_two = Post.objects.create(
text='Test user two post',
author=self.user_two,
group=self.test_group,
)
Follow.objects.create(user=self.user_one, author=self.user_two)
url = reverse('follow_index')
response = self.user_one_client.get(url)
actual = response.context['page'][0]
expected = test_post_user_two
msg = 'Неправильно работает страница избранного.'
self.assertEqual(actual, expected, msg)
response = self.user_two_client.get(url)
actual = response.context['paginator'].count
self.assertEqual(actual, 0, msg)
def test_auth_user_can_comment(self):
"""Пользователи могут добавлять комментарии, а гости нет."""
users = {
self.guest_client: False,
self.user_one_client: True,
}
for user, expected in users.items():
with self.subTest(user=user):
form_data = {
'text': 'comment',
}
user.post(
reverse('add_comment',
args=[self.user_one, self.test_post.id]),
data=form_data,
follow=True,
)
actual = Comment.objects.filter(
post=self.test_post,
author=self.user_one,
text=form_data['text'],
).exists()
msg = f'Ошибка добавления комментария у {user}'
self.assertEqual(actual, expected, msg)
def test_cache(self):
"""Главная страница корректно кэширует список записей."""
response_before = self.user_one_client.get(reverse('index'))
page_before_clear_cache = response_before.content
post = Post.objects.latest('id')
post.text = 'Кэш ' + post.text
post.save()
response_before = self.user_one_client.get(reverse('index'))
page_before_clear_cache_refresh = response_before.content
self.assertEqual(page_before_clear_cache,
page_before_clear_cache_refresh)
cache.clear()
response_after = self.user_one_client.get(reverse('index'))
page_after_clear_cache = response_after.content
self.assertNotEqual(page_before_clear_cache, page_after_clear_cache)
def test_url_templates(self):
"""Соответствие вызываемых шаблонов."""
user = self.user_one
post_id = self.test_post.id
urls = {
reverse('index'): 'index.html',
reverse('new_post'): 'new.html',
reverse('group', args=['group']): 'group.html',
reverse('group', args=['group']): 'group.html',
reverse('post_edit', args=[user, post_id]): 'new_post.html',
reverse('about:author'): 'about/author.html',
reverse('about:tech'): 'about/tech.html',
}
for url, expected in urls.items():
with self.subTest():
response = self.user_one_client.get(url)
msg = f'{url} не использует шаблон {expected}'
self.assertTemplateUsed(response, expected, msg)
def test_index_context(self):
"""На главной странице существует пост и правильный контекст."""
response = self.user_one_client.get(reverse('index'))
expected = self.test_post
msg = 'На главной странице неправильный context или нет нового поста'
self.assertEqual(response.context['page'][0], expected, msg)
def test_group_context(self):
"""На странице группы правильный контекст."""
url = reverse('group', args=['group'])
response = self.user_one_client.get(url)
expected = self.test_group
msg = 'На странице группы неправильный context'
self.assertEqual(response.context['group'], expected, msg)
def test_new_post_context(self):
"""На странице создания поста правильный контекст."""
fields = {
'text': forms.fields.CharField,
'group': forms.models.ModelChoiceField,
'image': forms.fields.ImageField,
}
response = self.user_one_client.get(reverse('new_post'))
form = response.context['form']
for field, expected in fields.items():
with self.subTest(field=field):
msg = 'На странице создания поста неправильный context'
self.assertIsInstance(form.fields[field], expected, msg)
def test_post_edit_context(self):
"""На странице редактирования поста правильный контекст."""
url = reverse('post_edit', args=[self.user_one, self.test_post.id])
response = self.user_one_client.get(url)
form = response.context['form']
context = {
'post': self.test_post,
'is_edit': True,
}
for value, expected in context.items():
with self.subTest(value=value):
msg = f'{value} контекста не равно {expected}'
self.assertEqual(response.context[value], expected, msg)
fields = {
'text': forms.fields.CharField,
'group': forms.models.ModelChoiceField,
}
for field, expected in fields.items():
with self.subTest(field=field):
msg = 'На странице редактирования поста неправильный context'
self.assertIsInstance(form.fields[field], expected, msg)
def test_profile_context(self):
"""На странице автора правильный контекст."""
user = self.user_one
url = reverse('profile', args=[user])
response = self.user_one_client.get(url)
context = {
'author': user,
# 'posts': self.test_post,
}
for value, expected in context.items():
with self.subTest(value=value):
msg = f'{value} контекста не равно {expected}'
self.assertEqual(response.context[value], expected, msg)
def test_post_view_context(self):
"""На странице поста правильный контекст."""
url = reverse('post', args=[self.user_one, self.test_post.id])
response = self.user_one_client.get(url)
context = {
'post': self.test_post,
'author': self.user_one,
}
for value, expected in context.items():
with self.subTest(value=value):
msg = f'{value} контекста не равно {expected}'
self.assertEqual(response.context[value], expected, msg)
def test_group_post(self):
"""На странице группы отображается новый пост."""
response = self.user_one_client.get(reverse('group', args=['group']))
expected = self.test_post
msg = 'На странице группы не отображается новый пост'
self.assertEqual(response.context['page'][0], expected, msg)
def test_another_group_post(self):
"""На странице другой группы не отображается новый пост."""
path = reverse('group', args=['second-group'])
response = self.user_one_client.get(path)
response = response.context['page'].object_list.count()
expected = 0
msg = 'На странице другой группы не должен отображаться новый пост'
self.assertEqual(response, expected, msg)
def test_successful_logout(self):
"""Test successfully logged out."""
c = Client()
response = c.get('/accounts/logout/')
self.assertEqual(response.status_code, 200)
def test_blog_page_status_code(self):
client = Client()
response = client.get('/blog/')
self.assertEqual(response.status_code, 200)
def test_home_view(self):
"""Tests successful retrieval of home view."""
c = Client()
reponse = c.get('/')
self.assertEqual(reponse.status_code, 200)
def test_ethereum_view(self):
client = Client()
response = client.get(reverse('ethereum:ethereum'))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'ethereum/ethereum.html')
def test_index(self):
c = Client()
response = c.get("/")
self.assertEqual(response.status_code, 200)
class ViewTest(TestCase):
"""Tests for user_login view"""
def setUp(self):
self.client = Client(enforce_csrf_checks=True)
self.client.get("/") # To get the CSRF token for next request
assert django_settings.CSRF_COOKIE_NAME in self.client.cookies
self.target_user = User.objects.create(username="******")
def get_csrf_token_payload(self):
return {
"csrfmiddlewaretoken":
self.client.cookies[django_settings.CSRF_COOKIE_NAME].value
}
def get_target_url(self, target_user=None):
if target_user is None:
target_user = self.target_user
response = self.client.post(reverse("loginas-user-login",
kwargs={"user_id":
target_user.id}),
data=self.get_csrf_token_payload())
self.assertEqual(response.status_code, 302)
return response
def assertCurrentUserIs(self, user):
id_ = str(user.id if user is not None else None).encode("utf-8")
r = self.client.post(reverse("current_user"),
data=self.get_csrf_token_payload())
self.assertEqual(r.content, id_)
def assertLoginError(self, resp, message=None):
self.assertEqual(urlsplit(resp["Location"])[2], "/")
message = message or "You do not have permission to do that."
messages = CookieStorage(resp)._decode(resp.cookies["messages"].value)
self.assertIn((40, message), [(m.level, m.message) for m in messages])
def assertLoginSuccess(self, resp, user):
self.assertEqual(
urlsplit(resp["Location"])[2], django_settings.LOGIN_REDIRECT_URL)
msg = la_settings.MESSAGE_LOGIN_SWITCH.format(
username=user.__dict__[la_settings.USERNAME_FIELD])
messages = CookieStorage(resp)._decode(resp.cookies["messages"].value)
self.assertIn(msg, "".join([m.message for m in messages]))
def assertRaisesExact(self, exception, func, *args, **kwargs):
try:
func(*args, **kwargs)
self.assertFail("{0} not raised".format(exception))
except exception.__class__ as caught:
self.assertEqual(caught.args, exception.args)
def clear_session_cookie(self):
del self.client.cookies[django_settings.SESSION_COOKIE_NAME]
@override_settings(CAN_LOGIN_AS=login_as_nonstaff)
def test_custom_permissions(self):
user = create_user("üser", "pass", is_superuser=False, is_staff=False)
staff1 = create_user("stäff",
"pass",
is_superuser=False,
is_staff=True)
staff2 = create_user("super", "pass", is_superuser=True, is_staff=True)
# Regular user can't login as anyone
self.assertTrue(self.client.login(username="******", password="******"))
self.assertLoginError(self.get_target_url())
self.assertCurrentUserIs(user)
self.clear_session_cookie()
# Non-superuser staff user can login as regular user
self.assertTrue(self.client.login(username="******", password="******"))
response = self.get_target_url(user)
self.assertLoginSuccess(response, user)
self.assertCurrentUserIs(user)
self.clear_session_cookie()
# Non-superuser staff user cannot login as other staff
self.assertTrue(self.client.login(username="******", password="******"))
self.assertLoginError(self.get_target_url(staff2))
self.assertCurrentUserIs(staff1)
self.clear_session_cookie()
# Superuser staff user can login as other staff
self.assertTrue(self.client.login(username="******", password="******"))
response = self.get_target_url(staff1)
self.assertLoginSuccess(response, staff1)
self.assertCurrentUserIs(staff1)
@override_settings(CAN_LOGIN_AS="loginas.tests.login_as_shorter_username")
def test_custom_permissions_as_string(self):
ray = create_user("ray", "pass")
lonnie = create_user("lonnie", "pass")
# Ray cannot login as Lonnie
self.assertTrue(self.client.login(username="******", password="******"))
self.assertLoginError(self.get_target_url(lonnie))
self.assertCurrentUserIs(ray)
self.clear_session_cookie()
# Lonnie can login as Ray
self.assertTrue(self.client.login(username="******", password="******"))
response = self.get_target_url(ray)
self.assertLoginSuccess(response, ray)
self.assertCurrentUserIs(ray)
def test_custom_permissions_invalid_path(self):
def assertMessage(message):
self.assertRaisesExact(ImproperlyConfigured(message),
self.get_target_url)
with override_settings(CAN_LOGIN_AS="loginas.tests.invalid_func"):
assertMessage(
"Module loginas.tests does not define a invalid_func function."
)
with override_settings(CAN_LOGIN_AS="loginas.tests.invalid_path.func"):
assertMessage(
"Error importing CAN_LOGIN_AS function: loginas.tests.invalid_path"
)
def test_as_superuser(self):
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
self.assertCurrentUserIs(self.target_user)
def test_as_non_superuser(self):
user = create_user("me", "pass", is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
self.assertLoginError(self.get_target_url())
self.assertCurrentUserIs(user)
@unittest.skipIf(django.VERSION[:2] < (1, 10),
"Django < 1.10 allows to authenticate as inactive user")
def test_auth_backends_user_not_found(self):
superuser = create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
self.assertCurrentUserIs(superuser)
# ModelBackend should authenticate superuser but prevent this action for inactive user
inactive_user = create_user("name", "pass", is_active=False)
with self.settings(AUTHENTICATION_BACKENDS=(
"django.contrib.auth.backends.ModelBackend",
"tests.WrongAuthBackend")):
message = "Could not find an appropriate authentication backend"
self.assertLoginError(
self.get_target_url(target_user=inactive_user),
message=message)
self.assertCurrentUserIs(superuser)
@override_settings(CAN_LOGIN_AS=can_login_as_always_raise_permission_denied
)
def test_can_login_as_permission_denied(self):
message = "You can't login as target user"
self.assertLoginError(self.get_target_url(), message=message)
def test_as_anonymous_user(self):
self.assertLoginError(self.get_target_url())
self.assertCurrentUserIs(None)
def test_get_405_method_not_allowed(self):
url = reverse("loginas-user-login", kwargs={"user_id": "0"})
r = self.client.get(url)
self.assertEqual(r.status_code, 405)
def test_missing_csrf_token_403_forbidden(self):
url = reverse("loginas-user-login", kwargs={"user_id": "0"})
r = self.client.post(url)
self.assertEqual(r.status_code, 403)
@override_settings(LOGINAS_REDIRECT_URL="/another-redirect")
def test_loginas_redirect_url(self):
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
response = self.client.post(reverse(
"loginas-user-login", kwargs={"user_id": self.target_user.id}),
data=self.get_csrf_token_payload())
self.assertEqual(response.status_code, 302)
self.assertEqual(
urlsplit(response["Location"])[2], "/another-redirect")
def test_restore_original_user(self):
# Create a super user and login as this
original_user = create_user("me",
"pass",
is_superuser=True,
is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
url = reverse("loginas-user-login",
kwargs={"user_id": self.target_user.id})
self.client.get(url)
self.assertCurrentUserIs(self.target_user)
# Restore
url = reverse("loginas-logout")
self.client.get(url)
self.assertCurrentUserIs(original_user)
@override_settings(LOGINAS_LOGOUT_REDIRECT_URL="/another-redirect")
def test_loginas_redirect_url_again(self):
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
response = self.client.get(reverse("loginas-logout"))
self.assertEqual(response.status_code, 302)
self.assertEqual(
urlsplit(response["Location"])[2], "/another-redirect")
def test_last_login_not_updated(self):
last_login = timezone.now() - timedelta(hours=1)
self.target_user.last_login = last_login
self.target_user.save()
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
self.assertCurrentUserIs(self.target_user)
target_user = User.objects.get(
id=self.target_user.id) # refresh from db
self.assertEqual(target_user.last_login, last_login)
@override_settings(LOGINAS_UPDATE_LAST_LOGIN=True)
def test_last_login_updated(self):
last_login = timezone.now() - timedelta(hours=1)
self.target_user.last_login = last_login
self.target_user.save()
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
self.assertCurrentUserIs(self.target_user)
target_user = User.objects.get(
id=self.target_user.id) # refresh from db
self.assertGreater(target_user.last_login, last_login)
@override_settings(USERNAME_FIELD="email")
def test_custom_username_field(self):
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="******", password="******"))
self.target_user.email = "*****@*****.**"
self.target_user.save()
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
def test_afficher_tx_eth_view(self):
client = Client()
response = client.get(reverse('ethereum:afficher_tx_eth'))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'ethereum/transactions_eth.html')
