class OrderViewTests(TestCase): def setUp(self): self.testuser = User.objects.create_user(username='******',password='******', first_name='test',last_name='user') self.testusersp = add_sellerprofile(self.testuser) self.c = Client() self.c.login(username='******',password='******') self.assertTrue(self.c.login) self.testuser2 = User.objects.create_user(username='******',password='******') self.d = Client() self.d.login(username='******',password='******') self.assertTrue(self.d.login) self.testcat = add_cat('testcat') self.cash = PaymentChoice.objects.create(description='cash') self.testitem = add_item(title='testitem',asking_price=100, category=self.testcat,owner=self.testusersp) self.order = Order.objects.create(buyer=self.testuser2,meetuploc='pielantis', phone=12313132,paymentmethod=self.cash,buy_item=self.testitem) def tearDown(self): self.c.logout() self.d.logout() def test_user_without_sellerprofile_can_access_order_page(self): response = self.d.get(reverse('shop:order', kwargs={'order_id': self.order.id})) self.assertEqual(response.status_code, 200)
class AddNewItemViewTests(TestCase): def setUp(self): testuser = User.objects.create_user(username='******',password='******') testusersp = add_sellerprofile(testuser) self.c = Client() self.c.login(username='******',password='******') self.assertTrue(self.c.login) def tearDown(self): self.c.logout() def test_valid_saleitem_creation(self): testcat = add_cat('testcat') data = {'title': 'testtitle','condition': 'NEW', 'description': 'its legit', 'asking_price': 334334, 'payment_type':'COD', 'negotiable': True, 'expiration_date': '4/4/2015', 'category': testcat.id, 'refundable': True, 'home_delivery': True} form = SaleItemForm(data=data) print form.errors self.assertTrue(form.is_valid()) response = self.c.post(reverse('shop:add_new_item'), data) self.assertEqual(response.status_code, 302)
class AcceptBidViewTests(TestCase): def setUp(self): self.testuser = User.objects.create_user(username='******',password='******') self.testusersp = add_sellerprofile(self.testuser) self.c = Client() self.c.login(username='******',password='******') self.assertTrue(self.c.login) def tearDown(self): self.c.logout() def test_valid_accept_bid(self): testcat = add_cat('testcat') testitem = add_item(title='testitem',asking_price=100, category=testcat,owner=self.testusersp) self.assertTrue(testitem.available) testbid = UserBid.objects.create(user=self.testuser,sale_item=testitem,offer_price=200) response = self.c.post(reverse('shop:acceptbid', kwargs={'bid_id':testbid.id})) self.assertEqual(response.status_code, 302) testitemafter = SaleItem.objects.get(slug='testitem') self.assertEqual(testitemafter.accepted_bid, testbid) self.assertFalse(testitemafter.available) def test_item_owner_can_access_accept_bid_view(self): testcat = add_cat('testcat') testitem = add_item(title='testitem',asking_price=100, category=testcat,owner=self.testusersp) self.assertTrue(testitem.available) testbid = UserBid.objects.create(user=self.testuser,sale_item=testitem,offer_price=200) response = self.c.get(reverse('shop:acceptbid', kwargs={'bid_id':testbid.id})) self.assertEqual(response.status_code, 200) self.assertEqual(response.context['bid'], testbid)
def test_index(self): """ Test for the main view. """ c = Client() response = c.get(reverse('file_service', kwargs=dict(key='test'))) # Non-authenticated user should return 401 self.assertEqual(response.status_code, 401) logged_in = c.login(username='******', password='******') self.assertTrue(logged_in) # An authenticated user should return a 200 response = c.get(reverse('file_service', kwargs=dict(key='test'))) self.assertEqual(response.status_code, 200) c.logout() # A client should get a 200 response with basic authorization headers = dict(HTTP_AUTHORIZATION="basic dGVzdF9hZG1pbjphZG1pbg==") response = c.get(reverse('file_service', kwargs=dict(key='test')), **headers) self.assertEqual(response.status_code, 200) # A client should get a 401 response with incorrect basic authorization headers = dict(HTTP_AUTHORIZATION="basic dGasdasdsabg==") response = c.get(reverse('file_service', kwargs=dict(key='test')), **headers) self.assertEqual(response.status_code, 401)
class homePage(TestCase): def setUp(self): self.client = Client() def test_login(self): self.assertEquals(reverse("audio:index"), '/audio/') def test_anon(self): response = self.client.get(reverse("login")) self.assertEquals(response.status_code, 200) response = self.client.get(reverse("audio:index")) self.assertEquals(response.status_code, 302) def test_not_anon(self): user = User.objects.create_user( username="******", password="******" ) login_status = self.client.login( username='******', password='******' ) self.assertTrue(login_status) response = self.client.get(reverse("login")) self.assertEquals(response.status_code, 302) response = self.client.get(reverse("audio:index")) self.assertEquals(response.status_code, 200) self.client.logout()
class AlertTest(TestCase): fixtures = ['test_court.json', 'authtest_data.json'] def setUp(self): # Set up some handy variables self.client = Client() self.alert_params = { 'query': 'q=asdf', 'name': 'dummy alert', 'rate': 'dly', } def test_create_alert(self): """Can we create an alert by sending a post?""" self.client.login(username='******', password='******') r = self.client.post(reverse('show_results'), self.alert_params, follow=True) self.assertEqual(r.redirect_chain[0][1], 302) self.assertIn('successfully', r.content) self.client.logout() def test_fail_gracefully(self): """Do we fail gracefully when an invalid alert form is sent?""" # Use a copy to shield other tests from changes. bad_alert_params = self.alert_params.copy() # Break the form bad_alert_params.pop('query', None) self.client.login(username='******', password='******') r = self.client.post('/', bad_alert_params, follow=True) self.assertEqual(r.status_code, 200) self.assertIn('error creating your alert', r.content) self.client.logout()
def test_anonymous(self): # Load the page with a user, should load as normal c = Client() response = c.get('/nation/1/',follow=True) self.assertEqual(response.redirect_chain,[]) self.assertEqual(response.status_code,200) c.logout()
def test_mi_panel(self): """ Comprueba la vista mi_panel Comprueba que muestra las reservas del profesor si el usuario es un profesor Comprueba que muestra los datos del admin si el usuario es un admin Comprueba que muestra las opciones del alumno si el usuario es un alumno """ c = Client() c.login(username="******", password="******") response = c.post('/miPanel/') boolean = True if 'reservas' in response.context['datos'] else False self.assertEquals(boolean, True) c.logout() c.login(username="******", password="******") response = c.post('/miPanel/') boolean = True if 'usuarios' in response.context['datos'] else False self.assertEquals(boolean, True) c.logout() c.login(username="******", password="******") response = c.post('/miPanel/') boolean = True if 'reservas' in response.context else False self.assertEquals(boolean, False)
class MainPageTestCase(TestCase): def _create_packages(self, user): for x in xrange(self.COUNT): Package.objects.create(title=self.PACKAGE_NAME_TEMPLATE % (user.username,x), user=user) def setUp(self): _create_basic_database() self.c = Client() # login self.c.login(username=TEST_USER, password=TEST_PASSWORD) def test_basic_elements(self): response = self.c.get('/exeapp/') self.assertContains(response, "Main Page") self.assertContains(response, "Package") def _test_create_package(self): PACKAGE_NAME = '%s Package post' % self.TEST_USER response = self.s.app.register(PACKAGE_NAME) p = Package.objects.get(title=PACKAGE_NAME) self.assertTrue(p.user.username == self.TEST_USER) def test_require_login(self): self.c.logout() response = self.c.get('/exeapp/main') self.assertFalse('Main Page' in response.content)
class TestSignUpView(TestCase): def setUp(self): self.user = self.create_user_django() self.client = Client() def tearDown(self): self.user.delete() def create_user_django(self): user = User.objects.create_user("USERtestCoLaB", "*****@*****.**", "123colab4") return user def test_user_authenticated_and_unregistered(self): self.client.login(username="******", password="******") response = self.client.get("/account/register/") self.assertEquals(200, response.status_code) self.client.logout() def test_user_authenticated_and_registered(self): self.user.needs_update = False self.user.save() self.client.login(username="******", password="******") response = self.client.get("/account/register/") self.assertEquals(302, response.status_code) url = "http://testserver/account/usertestcolab" self.assertEquals(url, response.url) self.client.logout()
class ModelsTestCase(TestCase): def setUp(self): self.u = User.objects.create(username='******', password='******') self.u2 = User.objects.create(username='******', password='******') self.c = Category.objects.create(category_name='test_category') self.client = Client() self.request = RequestFactory() def testPurchasedProductsPageRedirect(self): self.client.logout() response = self.client.get(reverse('bidplacing:purchased_products_page')) self.assertEqual(response.status_code, 302) def testAddProduct(self): request = self.request.post(reverse('bidplacing:new_product'), {'product_name': 'test_product', 'start_price': 5, 'category': self.c}) request.user = self.u response = new_product(request) self.assertEqual(response.status_code, 200) def testAddProductNegativePrice(self): form = ProductForm({'product_name': 'test_product', 'start_price': -64, 'category': self.c}) self.assertFalse(form.is_valid())
class SessionAuthTests(TestCase): """User session authentication""" urls = 'djangorestframework.tests.authentication' def setUp(self): self.csrf_client = Client(enforce_csrf_checks=True) self.non_csrf_client = Client(enforce_csrf_checks=False) self.username = '******' self.email = '*****@*****.**' self.password = '******' self.user = User.objects.create_user(self.username, self.email, self.password) def tearDown(self): self.csrf_client.logout() def test_post_form_session_auth_failing_csrf(self): """Ensure POSTing form over session authentication without CSRF token fails.""" self.csrf_client.login(username=self.username, password=self.password) response = self.csrf_client.post('/', {'example': 'example'}) self.assertEqual(response.status_code, 403) def test_post_form_session_auth_passing(self): """Ensure POSTing form over session authentication with logged in user and CSRF token passes.""" self.non_csrf_client.login(username=self.username, password=self.password) response = self.non_csrf_client.post('/', {'example': 'example'}) self.assertEqual(response.status_code, 200) def test_post_form_session_auth_failing(self): """Ensure POSTing form over session authentication without logged in user fails.""" response = self.csrf_client.post('/', {'example': 'example'}) self.assertEqual(response.status_code, 403)
class AdminLoginTest(TestCase): def setUp(self): self.new_user = User.objects.create_user(username='******', password='******') self.client = Client() def test_login_display(self): response = self.client.get('/admin/') self.assertEqual(response.status_code, 200) response = self.client.get('/admin/main/', follow=True) self.assertEqual(response.status_code, 404) response = self.client.login(username='******', password='******') self.assertTrue(response) response = self.client.get('/admin/main/') self.assertEqual(response.status_code, 200) self.client.logout() response = self.client.get('/admin/main/', follow=True) self.assertEqual(response.status_code, 404) def test_login_fail(self): response = self.client.login(username='******', password='******') self.assertFalse(response) response = self.client.get('/admin/main/', follow=True) self.assertEqual(response.status_code, 404)
class GradeViewTest(TestCase): def setUp(self): self.client = Client() def tearDown(self): self.client.logout() def test_grade_view(self): # Given # URL redirection due to no login credentials status_code = 302 # When response = self.client.get(reverse('grades:grading_systems')) # Then self.assertEqual(response.status_code, status_code) # Given # successful login and grading systems views self.client.login(username='******', password='******') status_code = 200 # When response = self.client.get(reverse('grades:grading_systems')) # Then self.assertEqual(response.status_code, status_code) self.assertTemplateUsed(response, 'grading_systems.html')
class HomePageTest(TestCase): def setUp(self): self.c = Client() self.user = User.objects.create(username='******',password='******') self.user.set_password('hello') self.user.save() # A dummy user for testing... def test_root_url_resolves_to_index_view(self): found = resolve('/') self.assertEqual(found.func, index) def test_existing_login(self): login = self.c.login(username='******',password='******') if login : self.c.logout() self.assertTrue(login) def test_non_existing_login(self): login2 = authenticate(username='******', password='******') # login2 == None implies the user doesn't exist... self.assertEqual(login2,None) def test_incorrect_password(self): user3 = authenticate(username='******',password='******') login3 = self.c.login(username='******',password='******') # login3 == False implies the user's credentials are invalid... self.assertTrue(not login3 and user3 != None)
class LoginTest(SimpleTestCase): user = '******' pwd = '123456' def setUp(self): self.client = Client() if not User.objects.filter(username=self.user).first(): User.objects.create_user(username=self.user, password=self.pwd) def test_200ok(self): self.assertEqual(self.client.get('/login/').status_code, 200) self.assertEqual(self.client.post('/login/').status_code, 200) def test_login_normal(self): self.assertTrue(self.client.login(username=self.user, password=self.pwd)) self.client.logout() res = self.client.post(path='/login/', data={'username': self.user, 'password': self.pwd}) self.assertEqual(res.url, 'http://testserver/index.html') def test_login_nextpage(self): res = self.client.post(path='/login/', data={'username': self.user, 'password': self.pwd, 'next': '/404/'}) self.assertEqual(res.status_code, 302) def test_logout(self): self.assertIsNone(self.client.logout()) self.client.login(username=self.user, password=self.pwd) self.assertIsNone(self.client.logout())
class TestProfileViewing(TestCase): def setUp(self): self.c = Client() r = RedditUser.objects.create(user=User.objects.create_user(username="******", password="******")) r.first_name = "First Name" r.last_name = "Last Name" r.about_html = "about html text" r.github = "example" def test_existing_username(self): r = self.c.get(reverse("user_profile", args=("username",))) self.assertEqual(r.status_code, 200) self.assertContains(r, "(username)") self.assertContains(r, "compose?to=username") self.assertNotContains(r, "/profile/edit") self.assertNotContains(r, "First Name") self.assertNotContains(r, "Last Name") self.assertNotContains(r, "about html text") self.assertNotContains(r, "https://github.com/example") def test_own_username(self): self.assertTrue(self.c.login(username="******", password="******")) r = self.c.get(reverse("user_profile", args=("username",))) self.assertContains(r, "/profile/edit") self.assertNotContains(r, "compose?to=username") self.c.logout() def test_invalid_username(self): r = self.c.get(reverse("user_profile", args=("none",))) self.assertEqual(r.status_code, 404)
class AlertTest(TestCase): fixtures = ["test_court.json", "authtest_data.json"] def setUp(self): # Set up some handy variables self.client = Client() self.alert_params = {"query": "q=asdf", "name": "dummy alert", "rate": "dly"} def test_create_alert(self): """Can we create an alert by sending a post?""" self.client.login(username="******", password="******") r = self.client.post(reverse("show_results"), self.alert_params, follow=True) self.assertEqual(r.redirect_chain[0][1], 302) self.assertIn("successfully", r.content) self.client.logout() def test_fail_gracefully(self): """Do we fail gracefully when an invalid alert form is sent?""" # Use a copy to shield other tests from changes. bad_alert_params = self.alert_params.copy() # Break the form bad_alert_params.pop("query", None) self.client.login(username="******", password="******") r = self.client.post("/", bad_alert_params, follow=True) self.assertEqual(r.status_code, 200) self.assertIn("error creating your alert", r.content) self.client.logout()
class LogoutTests(TestCase): def setUp(self): self.client = Client() self.register_user = { 'username': "******", 'email': '*****@*****.**', 'password': "******", } self.log_user = { 'username': self.register_user['username'], 'password': self.register_user['password'], } unittest_fr = User.objects.create_user(**self.register_user) UserLang.objects.create(user=unittest_fr, lang='fr') def test_logout_user(self): self.client.login(username=self.log_user['username'], password=self.log_user['password']) reponse = self.client.get(reverse('logout')) self.assertEqual(reponse.status_code, 301) self.client.logout() def test_logout_url_unlog(self): """ tests access to url contact not log status :var reponse: response of request :todo: see how to remove next when referer is logout :return: None """ reponse = self.client.get(reverse('logout')) self.assertRedirects(reponse, reverse('login') + '?next=' + reverse('logout'))
class UserPageTest(TestCase): def setUp(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) def test_user_view_exists(self): request = HttpRequest() Bob = User.objects.get(username='******') request.user = Bob response = user_page(request) self.assertContains(response, 'Change Password') def test_user_page_exists(self): response = self.client.get('/user/') self.assertEquals(response.status_code, 200) def test_user_page_requires_login(self): self.client.logout() response = self.client.get('/user/') self.assertRedirects(response, '/login/?next=/user/', status_code=302) def test_user_page_shows_correct_links(self): response = self.client.get('/user/') self.assertContains(response, "Reset Password") self.assertContains(response, "Logout")
class ThreadUrlsTestCase(BaseTestCase): def setUp(self): super(ThreadUrlsTestCase, self).setUp() self.client = Client() def tearDown(self): self.client.logout() super(ThreadUrlsTestCase, self).tearDown() def test_new_url(self): self.client.login( username=self.user.username, password=self._password) response = self.client.get(reverse('threads:new')) self.assertEqual(response.status_code, 200) def test_show_url(self): forum = Forum.objects.create( name='Forum', description='A forum', active=True, ) thread = Thread.objects.create(subject='Thread', forum=forum) response = self.client.get(reverse( 'threads:show', kwargs={'slug': thread.slug})) self.assertEqual(response.status_code, 200) def test_show_url_not_valid(self): response = self.client.get(reverse( 'threads:show', kwargs={'slug': 'does-not-exist'})) self.assertEqual(response.status_code, 404)
class SignOut(TestCase): def setUp(self): self.client = Client() self.chester = User.objects.create_user(first_name='Chester', last_name='Tester', email='*****@*****.**', username='******', password='******') self.client.logout() def tearDown(self): pass def test_010_SignOutNotSignedIn(self): """Sign Out when no-one is signed in - should not result in an error""" ts = now() self.assertFalse('_auth_user_id' in self.client.session) r = self.client.get(reverse('User:SignOut')) self.assertEqual(r.resolver_match.func.__name__, views.SignOut.__name__) self.assertRedirects(r, reverse('Home')) self.assertFalse('_auth_user_id' in self.client.session) self.assertTrue(PageVisit.most_recent(document='User:SignOut', user=None) is None) def test_011_SignOutOk(self): """Sign Out when user is signed in - must result in correct logout""" ts = now() self.assertTrue(self.client.login(username='******', password='******')) self.assertTrue(self.client.session['_auth_user_id'], self.chester.pk) response = self.client.get(reverse('User:SignOut')) self.assertRedirects(response, reverse('Home')) self.assertFalse('_auth_user_id' in self.client.session) self.assertAlmostEqual(PageVisit.most_recent('User:SignOut').timestamp, ts, delta=timedelta(milliseconds=200))
def test_first_time(self): # check that system detects first time user c = Client() c.logout() c.login(username="******", password="******") response = c.get("/settings", follow=True) self.assertIn(b"first time", response.content)
def test_user_data1(self): ''' Another method for basic tests. :return: ''' c = Client() response = self.client.post('/signup/', {'username': '******', 'password': '******', 'email': '*****@*****.**', 'first_name': 'old_first_name2', 'last_name': 'old_last_name'}) self.assertEqual(200, response.status_code) c.logout() c.login(username='******', password='******') response=c.post('/change_user_data/', {'new_first_name': 'newFN', 'new_last_name': 'newLN', 'new_email': '*****@*****.**'}) self.assertEqual(302, response.status_code) user = User.objects.get(username='******') self.assertEqual("newFN",user.first_name) self.assertEqual("newLN",user.last_name) self.assertEqual("*****@*****.**",user.email)
class AdminTest(LiveServerTestCase): fixtures = ['users.json'] def setUp(self): self.client = Client() def test_Login(self): response = self.client.get('/admin/', follow=True) self.assertEquals(response.status_code, 200) self.assertTrue(b"Log in" in response.content) self.client.login(username='******', password='******') response = self.client.get('/admin/', follow=True) self.assertEquals(response.status_code, 200) self.assertTrue(b"Log out" in response.content) def test_Logout(self): self.client.login(username='******', password='******') response = self.client.get('/admin/', follow=True) self.assertEquals(response.status_code, 200) self.assertTrue(b"Log out" in response.content) self.client.logout() response = self.client.get('/admin/', follow=True) self.assertEquals(response.status_code, 200) self.assertTrue(b"Log in" in response.content)
class TestOperateCategoryView(BasePlanCase): """Tests for operating category on cases""" @classmethod def setUpTestData(cls): super(TestOperateCategoryView, cls).setUpTestData() cls.case_cat_full_auto = TestCaseCategoryFactory(name='Full Auto', product=cls.product) cls.case_cat_full_manual = TestCaseCategoryFactory(name='Full Manual', product=cls.product) cls.tester = User.objects.create(username='******', email='*****@*****.**') cls.tester.set_password('password') cls.tester.save() user_should_have_perm(cls.tester, 'testcases.add_testcasecomponent') cls.case_category_url = reverse('tcms.testcases.views.category') def setUp(self): self.client = Client() self.client.login(username=self.tester.username, password='******') def tearDown(self): self.client.logout() def test_show_categories_form(self): response = self.client.post(self.case_category_url, {'product': self.product.pk}) self.assertContains( response, '<option value="{}" selected="selected">{}</option>'.format( self.product.pk, self.product.name), html=True) categories = ('<option value="{}">{}</option>'.format(category.pk, category.name) for category in self.product.category.all()) self.assertContains( response, '''<select multiple="multiple" id="id_o_category" name="o_category"> {} </select>'''.format(''.join(categories)), html=True) def test_update_cases_category(self): post_data = { 'from_plan': self.plan.pk, 'product': self.product.pk, 'case': [self.case_1.pk, self.case_3.pk], 'a': 'update', 'o_category': self.case_cat_full_auto.pk, } response = self.client.post(self.case_category_url, post_data) data = json.loads(response.content) self.assertEqual({'rc': 0, 'response': 'ok', 'errors_list': []}, data) for pk in (self.case_1.pk, self.case_3.pk): case = TestCase.objects.get(pk=pk) self.assertEqual(self.case_cat_full_auto, case.category)
class UpdateProfileTests(TestCase): def setUp(self): self.c = Client() response = self.c.post(reverse('register'), data={'firstname': 'Test', 'lastname': 'User', 'email': '*****@*****.**', 'password1': '1234', 'password2': '1234'}, follow=True) self.newUser = UserProfile.objects.latest('user') self.failUnlessEqual(response.status_code, 200) def test_change_username(self): self.c.post(reverse('login'), { 'email': '*****@*****.**', 'password': '******'}, follow=True) response = self.c.post(reverse('updateUser'), {'firstname': 'Altered', 'lastname': 'Test', 'userPassword': '******'}, follow=True) self.failUnlessEqual(response.status_code, 200) self.assertEqual(self.newUser.user.first_name, 'Altered') self.assertEqual(self.newUser.user.last_name, 'Test') def test_change_password(self): response = self.c.post(reverse('updateUser'), { 'password1': '4321', 'password2': '4321', 'userPassword': '******'}, follow=True) self.failUnlessEqual(response.status_code, 200) username = self.newUser.user.username self.c.logout() self.failUnlessEqual(self.c.login(username=username, password='******'), True) def test_password_failure(self): response = self.c.post(reverse('updateUser'), data={'firstname': 'Frank', 'userPassword': '******'}) self.assertEqual(response.status_code, 200) self.failIf(response.context['form'].is_valid()) self.assertFormError(response, 'form', field=None, errors=u'Password incorrect, try again') def test_change_password_failure(self): response = self.c.post(reverse('updateUser'), data={ 'password1': 4321, 'password2': 5321, 'userPassword': '******'}) self.assertEqual(response.status_code, 200) self.failIf(response.context['form'].is_valid()) self.assertFormError(response, 'form', field=None, errors=u'You must type the same password each time') def test_delete_account(self): amountUsers = UserProfile.objects.count() response = self.c.get(reverse('delete_user'), follow=True) self.failUnlessEqual(response.status_code, 200) self.assertEqual(amountUsers-1, UserProfile.objects.count())
def test_basic_hijack(self): client = Client() client.login(username=self.superuser_username, password=self.superuser_password) hijacked_response = client.post('/hijack/%d/' % self.user.id, follow=True) self.assertEqual(hijacked_response.status_code, 200) hijack_released_response = client.post('/hijack/release-hijack/', follow=True) self.assertEqual(hijack_released_response.status_code, 200) client.logout()
def test_account_creation(self): # check that account creation goes off successfully c = Client() c.logout() Account.objects.all().delete() c.login(username="******", password="******") response = c.post("/settings/", {"vcode": "345Xgfh43", "keyid": "122345"}) self.assertIn(b"Account Created", response.content)
def test_handle_user_logout_no_user(self): """ Test if logout events are correctly handled when user was not login before logout. """ client = Client() client.logout() nb_events = LogEvent.objects.count() self.assertEqual(nb_events, 0)
class SessionDetailsViewTest(TestCase): @classmethod def setUpClass(cls): super(SessionDetailsViewTest, cls).setUpClass() cls.domain = Domain(name="toyland", is_active=True) cls.domain.save() cls.couch_user = CommCareUser.create(cls.domain.name, 'bunkey', '123', None, None) cls.sql_user = cls.couch_user.get_django_user() cls.expected_response = { 'username': cls.sql_user.username, 'djangoUserId': cls.sql_user.pk, 'superUser': cls.sql_user.is_superuser, 'authToken': None, 'domains': [cls.domain.name], 'anonymous': False, 'enabled_toggles': [], 'enabled_previews': [], } cls.url = reverse('session_details') def setUp(self): # logs in the mobile worker every test so a new session is setup self.client = Client() self.client.login(username='******', password='******') self.session = self.client.session self.session.save() self.session_key = self.session.session_key @classmethod def tearDownClass(cls): cls.couch_user.delete(cls.domain.name, deleted_by=None) cls.domain.delete() super(SessionDetailsViewTest, cls).tearDownClass() def _assert_session_expiry_in_minutes(self, expected_minutes, actual_time_string): delta = parse_datetime(actual_time_string) - datetime.datetime.utcnow( ).replace(tzinfo=pytz.utc) diff_in_minutes = delta.days * 24 * 60 + delta.seconds / 60 self.assertEqual(expected_minutes, round(diff_in_minutes)) @softer_assert() def test_session_details_view(self): data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'}) response = _post_with_hmac(self.url, data, content_type="application/json") self.assertEqual(200, response.status_code) self.assertJSONEqual(response.content, self.expected_response) @softer_assert() def test_session_details_view_expired_session(self): self.session.set_expiry(-1) # 1 second in the past self.session.save() data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'}) response = _post_with_hmac(self.url, data, content_type="application/json") self.assertEqual(404, response.status_code) @softer_assert() def test_session_details_view_updates_session(self): expired_date = self.session.get_expiry_date() data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'}) response = _post_with_hmac(self.url, data, content_type="application/json") self.assertEqual(200, response.status_code) self.assertGreater(self.session.get_expiry_date(), expired_date) @flag_enabled('SECURE_SESSION_TIMEOUT') def test_secure_sessions(self): def _assertSecureSessionExpiry(previous_expiry, timeout_in_minutes): self.assertEqual(True, self.client.session.get('secure_session')) self.assertEqual(timeout_in_minutes, self.client.session.get('secure_session_timeout')) self.assertNotEqual(previous_expiry, self.client.session.get_expiry_date()) expiring_in = (self.client.session.get_expiry_date() - datetime.datetime.utcnow()).seconds self.assertGreater(expiring_in, timeout_in_minutes * 60 - 2) self.assertLess(expiring_in, timeout_in_minutes * 60 + 2) # Turn on secure sessions self.domain.secure_sessions = True self.domain.save() # Sessions should now be secure and use timeout from settings expired_date = self.session.get_expiry_date() self.client.get(reverse('domain_homepage', args=[self.domain.name])) _assertSecureSessionExpiry(expired_date, settings.SECURE_TIMEOUT) # Turn on customized timeout custom_timeout = 10 self.domain.secure_sessions_timeout = custom_timeout self.domain.save() # Request a domain-specific page so the domain-specific timeout kicks in expired_date = self.session.get_expiry_date() self.client.get(reverse('domain_homepage', args=[self.domain.name])) _assertSecureSessionExpiry(expired_date, custom_timeout) # Request a non-domain-specific page, which still uses the domain-specific timeout saved in the session expired_date = self.session.get_expiry_date() self.client.get(reverse('ping_session')) _assertSecureSessionExpiry(expired_date, custom_timeout) # Test the session details view itself expired_date = self.session.get_expiry_date() data = json.dumps({ 'sessionId': self.session_key, 'domain': self.domain.name }) response = _post_with_hmac(self.url, data, content_type="application/json") self.assertEqual(200, response.status_code) _assertSecureSessionExpiry(expired_date, custom_timeout) # Going back to insecure sessions requires a logout to create a new session self.domain.secure_sessions_timeout = None self.domain.secure_sessions = False self.domain.save() self.client.logout() self.client.login(username='******', password='******') self.client.get(reverse('domain_homepage', args=[self.domain.name])) self.assertEqual(False, self.client.session.get('secure_session')) self.assertEqual(settings.INACTIVITY_TIMEOUT, self.client.session.get('secure_session_timeout')) def test_ping_login_unauth_user(self): client = Client() client.login(username='******', password='******') response = client.get(reverse('ping_login')) self.assertEqual(200, response.status_code) data = json.loads(response.content) self.assertFalse(data['success']) self.assertIsNone(data['session_expiry']) self.assertIsNone(data['secure_session_timeout']) self.assertFalse(data['secure_session']) self.assertEqual("", data['username']) def test_ping_login_auth_user(self): client = Client() client.login(username=self.couch_user.username, password='******') # First ping after login via client.login: authorized but no session expiry response = client.get(reverse('ping_login')) self.assertEqual(200, response.status_code) data = json.loads(response.content) self.assertTrue(data['success']) self.assertIsNone(data['session_expiry']) self.assertIsNone(data['secure_session_timeout']) self.assertFalse(data['secure_session']) self.assertEqual(self.couch_user.username, data['username']) # Request a page and then re-ping: session expiry should be based on INACTIVITY_TIMEOUT client.get(reverse('bsd_license')) response = client.get(reverse('ping_login')) data = json.loads(response.content) self.assertTrue(data['success']) self.assertEqual(self.couch_user.username, data['username']) self.assertFalse(data['secure_session']) self.assertEqual(settings.INACTIVITY_TIMEOUT, data['secure_session_timeout']) self._assert_session_expiry_in_minutes(settings.INACTIVITY_TIMEOUT, data['session_expiry']) # Ping some more, session_expiry should not change session_expiry = data['session_expiry'] client.get(reverse('ping_login')) response = client.get(reverse('ping_login')) data = json.loads(response.content) self.assertTrue(data['success']) self.assertEqual(self.couch_user.username, data['username']) self.assertEqual(session_expiry, data['session_expiry']) # Request a normal page, session_expiry should update client.get(reverse('bsd_license')) response = client.get(reverse('ping_login')) data = json.loads(response.content) self.assertTrue(data['success']) self.assertEqual(self.couch_user.username, data['username']) self.assertIsNotNone(data['session_expiry']) self.assertNotEqual(session_expiry, data['session_expiry']) def test_with_hmac_signing(self): data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'}) header_value = get_hmac_digest(settings.FORMPLAYER_INTERNAL_AUTH_KEY, data) response = Client().post(self.url, data, content_type="application/json", HTTP_X_MAC_DIGEST=header_value) self.assertEqual(200, response.status_code) self.assertJSONEqual(response.content, self.expected_response) def test_with_hmac_signing_fail(self): data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'}) response = Client().post(self.url, data, content_type="application/json", HTTP_X_MAC_DIGEST='bad signature') self.assertEqual(401, response.status_code) @softer_assert() @flag_enabled('FORM_LINK_WORKFLOW') @flag_enabled('CALC_XPATHS', is_preview=True) def test_session_details_view_toggles(self): toggles.all_toggles() data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'}) response = _post_with_hmac(self.url, data, content_type="application/json") self.assertEqual(200, response.status_code) expected_response = self.expected_response.copy() expected_response['enabled_toggles'] = ['FORM_LINK_WORKFLOW'] expected_response['enabled_previews'] = ['CALC_XPATHS'] self.assertJSONEqual(response.content, expected_response)
def test_ambulance_get_viewset(self): # instantiate client client = Client() # login as admin client.login(username=settings.MQTT['USERNAME'], password=settings.MQTT['PASSWORD']) # retrieve any ambulance response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a1.id)).data self.assertDictEqual(result, answer) # retrieve any ambulance response = client.get('/en/api/ambulance/{}/'.format(str(self.a2.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a2.id)).data self.assertDictEqual(result, answer) # retrieve any ambulance response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data self.assertDictEqual(result, answer) # logout client.logout() # login as testuser2 client.login(username='******', password='******') # retrieve own response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data self.assertDictEqual(result, answer) # retrieve someone else's response = client.get('/en/api/ambulance/{}/'.format(str(self.a2.id)), follow=True) self.assertEqual(response.status_code, 404) # can't read response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)), follow=True) self.assertEqual(response.status_code, 404) # logout client.logout() # login as testuser1 client.login(username='******', password='******') # retrieve someone else's response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)), follow=True) self.assertEqual(response.status_code, 404) # retrieve someone else's response = client.get('/en/api/ambulance/{}/'.format(str(self.a2.id)), follow=True) self.assertEqual(response.status_code, 404) response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)), follow=True) self.assertEqual(response.status_code, 404) # logout client.logout()
def test_ambulance_post_viewset(self): # instantiate client client = Client() # login as admin client.login(username=settings.MQTT['USERNAME'], password=settings.MQTT['PASSWORD']) # create ambulance response = client.post( '/en/api/ambulance/', { 'identifier': 'NEW-1897', 'capability': AmbulanceCapability.R.name, 'comment': 'no comments' }) self.assertEqual(response.status_code, 201) a = Ambulance.objects.get(identifier='NEW-1897') # retrieve ambulance response = client.get('/en/api/ambulance/{}/'.format(str(a.id))) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(a).data self.assertDictEqual(result, answer) # create ambulance (repeated identifier) response = client.post( '/en/api/ambulance/', { 'identifier': 'NEW-1897', 'capability': AmbulanceCapability.R.name, 'comment': 'no comments' }) self.assertEqual(response.status_code, 400) result = JSONParser().parse(BytesIO(response.content)) self.assertEqual(result['identifier'], ['ambulance with this identifier already exists.']) # logout client.logout() # login as testuser2 client.login(username='******', password='******') response = client.post( '/en/api/ambulance/', { 'identifier': 'NEW-NEW-1897', 'capability': AmbulanceCapability.B.name, 'comment': 'more comments' }) self.assertEqual(response.status_code, 403) # logout client.logout() # login as testuser1 client.login(username='******', password='******') response = client.post( '/en/api/ambulance/', { 'identifier': 'NEW-NEW-1897', 'capability': AmbulanceCapability.B.name, 'comment': 'more comments' }) self.assertEqual(response.status_code, 403) # logout client.logout()
def test(self): # Bulk update ambulance a1 a = self.a1 user = self.u1 location0 = {'latitude': -3., 'longitude': 6.} location = {'latitude': -2., 'longitude': 7.} orientation = calculate_orientation(dict2point(location0), dict2point(location)) data = [{ 'status': AmbulanceStatus.AH.name, 'location': location0, }, { 'location': location, 'timestamp': timezone.now() }, { 'status': AmbulanceStatus.OS.name }] serializer = AmbulanceUpdateSerializer(data=data, many=True, partial=True) serializer.is_valid(raise_exception=True) serializer.save(ambulance=Ambulance.objects.get(id=a.id), updated_by=user) # test AmbulanceUpdateSerializer queryset = AmbulanceUpdate.objects.filter(ambulance=a) answer1 = [] for u in queryset: serializer = AmbulanceUpdateSerializer(u) result = { 'id': u.id, 'ambulance_id': u.ambulance.id, 'ambulance_identifier': u.ambulance.identifier, 'comment': u.comment, 'capability': u.capability, 'status': u.status, 'orientation': u.orientation, 'location': point2str(u.location), 'timestamp': date2iso(u.timestamp), 'updated_by_username': u.updated_by.username, 'updated_on': date2iso(u.updated_on) } answer1.append(serializer.data) self.assertDictEqual(serializer.data, result) # make sure last update is reflected in ambulance a = Ambulance.objects.get(id=a.id) serializer = AmbulanceSerializer(a) self.assertEqual(math.fabs(orientation - a.orientation) < 1e-4, True) orientation = a.orientation result = { 'id': a.id, 'identifier': a.identifier, 'comment': a.comment, 'capability': a.capability, 'status': AmbulanceStatus.OS.name, 'orientation': orientation, 'location': point2str(location), 'timestamp': date2iso(a.timestamp), 'client_id': None, 'updated_by': a.updated_by.id, 'updated_on': date2iso(a.updated_on) } self.assertDictEqual(serializer.data, result) # Bulk update ambulance a2 a = self.a3 user = self.u3 data = [{ 'status': AmbulanceStatus.AH.name, 'location': location0 }, { 'status': AmbulanceStatus.OS.name }, { 'location': location, 'timestamp': timezone.now() }] serializer = AmbulanceUpdateSerializer(data=data, many=True, partial=True) serializer.is_valid(raise_exception=True) serializer.save(ambulance=Ambulance.objects.get(id=a.id), updated_by=user) # test AmbulanceUpdateSerializer queryset = AmbulanceUpdate.objects.filter(ambulance=a) answer3 = [] for u in queryset: serializer = AmbulanceUpdateSerializer(u) result = { 'id': u.id, 'ambulance_id': a.id, 'ambulance_identifier': a.identifier, 'comment': u.comment, 'capability': u.capability, 'status': u.status, 'orientation': u.orientation, 'location': point2str(u.location), 'timestamp': date2iso(u.timestamp), 'updated_by_username': u.updated_by.username, 'updated_on': date2iso(u.updated_on) } answer3.append(serializer.data) self.assertDictEqual(serializer.data, result) # make sure last update is reflected in ambulance a = Ambulance.objects.get(id=a.id) serializer = AmbulanceSerializer(a) self.assertEqual(math.fabs(orientation - a.orientation) < 1e-4, True) orientation = a.orientation result = { 'id': a.id, 'identifier': a.identifier, 'comment': a.comment, 'capability': a.capability, 'status': AmbulanceStatus.OS.name, 'orientation': orientation, 'location': point2str(location), 'timestamp': date2iso(a.timestamp), 'client_id': None, 'updated_by': a.updated_by.id, 'updated_on': date2iso(a.updated_on) } self.assertDictEqual(serializer.data, result) # Test api # instantiate client client = Client() # login as admin client.login(username=settings.MQTT['USERNAME'], password=settings.MQTT['PASSWORD']) # retrieve ambulances updates response = client.get('/en/api/ambulance/{}/updates/'.format( self.a1.id), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertCountEqual(result, answer1) self.assertEqual(len(result), 4) # retrieve ambulances updates response = client.get('/en/api/ambulance/{}/updates/'.format( self.a3.id), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertCountEqual(result, answer3) self.assertEqual(len(result), 4) # logout client.logout() # login as testuser1 client.login(username='******', password='******') # retrieve ambulances response = client.get('/en/api/ambulance/{}/updates/'.format( self.a1.id), follow=True) self.assertEqual(response.status_code, 404) # retrieve ambulances response = client.get('/en/api/ambulance/{}/updates/'.format( self.a3.id), follow=True) self.assertEqual(response.status_code, 404) # logout client.logout() # login as testuser2 client.login(username='******', password='******') # retrieve ambulances response = client.get('/en/api/ambulance/{}/updates/'.format( self.a1.id), follow=True) self.assertEqual(response.status_code, 404) # retrieve ambulances updates response = client.get('/en/api/ambulance/{}/updates/'.format( self.a3.id), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertCountEqual(result, answer3) self.assertEqual(len(result), 4) # logout client.logout()
class ImageRepoTestCase(TestCase): def setUp(self): """Set up tests by creating an signing in a user and getting an image""" # create a temp dir to upload images settings.MEDIA_ROOT = tempfile.mkdtemp() # upload images to a temp dir for tests Image.image.field.storage = FileSystemStorage( location=settings.MEDIA_ROOT) self.client = Client() self.user1 = User.objects.create_user(username='******', password='******') self.client.login(username='******', password='******') with open('image_repo/test_data/test.png', 'rb') as file: self.upload_image = SimpleUploadedFile('test.png', file.read()) def tearDown(self): """Clean up resources from setup and tests""" # remove temp dir for uploaded images shutil.rmtree(settings.MEDIA_ROOT) # MODELS def test_save_image(self): """Test if uploaded image path is correct (models.save_image())""" new_img = Image.objects.create(image=self.upload_image, user=self.user1) self.assertEqual(new_img.image.url, '/user1/test.png') def test_image_create(self): """Test if Image instance is created (models.Image())""" new_img = Image.objects.create(image=self.upload_image, user=self.user1) new_img.save() self.assertIsInstance(new_img, Image) # FORMS def test_image_form(self): """Test if image form is valid (forms.ImageForm())""" form_data = {'image': self.upload_image} form = ImageForm(files=form_data) self.assertTrue(form.is_valid()) # VIEWS # sign up def test_sign_up_success_view(self): """Test if user signed up successfully (views.user_sign_up())""" self.client.logout() # use valid username and password resp = self.client.post( reverse('signup'), { 'username': '******', 'password1': 'Newuserpass', 'password2': 'Newuserpass' }) # make sure user is redirected to repo self.assertEqual(resp.status_code, 302) self.assertRedirects(resp, reverse('repo')) def test_sign_up_fail_view(self): """Test if user couldn't sign up (views.user_sign_up())""" self.client.logout() # use invalid password (too short) resp = self.client.post(reverse('signup'), { 'username': '******', 'password1': 'pass', 'password2': 'pass' }) self.assertEqual(resp.status_code, 401) self.assertEqual( resp.context['error'], 'Invalid username or password. Please choose another one.') # use invalid username (with '!') resp = self.client.post( reverse('signup'), { 'username': '******', 'password1': 'Password', 'password2': 'Password' }) self.assertEqual(resp.status_code, 401) self.assertEqual( resp.context['error'], 'Invalid username or password. Please choose another one.') # user different passwords resp = self.client.post(reverse('signup'), { 'username': '******', 'password1': 'pass1', 'password2': 'pass2' }) self.assertEqual(resp.status_code, 401) self.assertEqual(resp.context['error'], 'Passwords do not match.') # user already exists resp = self.client.post( reverse('signup'), { 'username': '******', 'password1': 'user1Pass', 'password2': 'user1Pass' }) self.assertEqual(resp.status_code, 401) self.assertEqual( resp.context['error'], 'Username is already used. Please choose another one.') # sign in def test_sign_in_success_view(self): """Test if user signed in successfully (views.user_sign_in())""" self.client.logout() # existing user credentials (from setUp()) resp = self.client.post(reverse('signin'), { 'username': '******', 'password': '******' }) # make sure user is redirected to repo self.assertEqual(resp.status_code, 302) self.assertRedirects(resp, reverse('repo')) def test_sign_in_fail_view(self): """Test if user couldn't sign in (views.user_sign_in())""" self.client.logout() # non existing user credentials resp = self.client.post(reverse('signin'), { 'username': '******', 'password': '******' }) self.assertEqual(resp.status_code, 401) self.assertEqual(resp.context['error'], 'Given username or password is incorrect.') # repo def test_redirect_unauth_view(self): """Test if unauthenticated user is redirected from views.repo()""" self.client.logout() resp = self.client.get(reverse('repo')) self.assertRedirects(resp, '/?next=/repo/') def test_auth_view(self): """Test if authenticated user can see views.repo()""" resp = self.client.get(reverse('repo')) self.assertEqual(resp.status_code, 200) self.assertTemplateUsed(resp, 'image_repo/repo.html') def test_auth_user_repo(self): """Test if user only sees their images (views.repo())""" # user1 uploads an image new_img = Image.objects.create(image=self.upload_image, user=self.user1) new_img.save() # check that user1 sees his data resp = self.client.get(reverse('repo')) # response context value of key 'images' (sent in views.repo()) # should be the same as query set of user1 self.assertQuerysetEqual(resp.context['images'], Image.objects.filter(user=self.user1)) # create a second user who has no images self.client.logout() self.user2 = User.objects.create_user(username='******', password='******') self.client.login(username='******', password='******') # check that user2 sees only their data resp = self.client.get(reverse('repo')) self.assertQuerysetEqual(resp.context['images'], Image.objects.filter(user=self.user2)) def test_image_upload(self): """Test if image gets uploaded in views.repo()""" resp = self.client.post(reverse('repo'), data={'image': self.upload_image}) self.assertEqual(resp.status_code, 200)
class ProfilePageTest(TestCase): fixtures = ['user'] def setUp(self): self.client = Client() self.user = User.objects.get(id=1) self.client.force_login(self.user) def test_success_get(self): response = self.client.get('/auth/user_profile/') self.assertEqual(response.status_code, 200) self.assertIn('user_form', response.context) self.assertIn('profile_form', response.context) def test_success_post(self): response = self.client.post('/auth/user_profile/', data={ 'first_name': 'Elena', 'last_name': 'Samoilenko' }) self.user.refresh_from_db() self.assertRedirects(response, '/auth/user_profile/') self.assertEqual(self.user.first_name, 'Elena') self.assertEqual(self.user.last_name, 'Samoilenko') def test_anonymous_user(self): self.client.logout() response = self.client.get('/auth/user_profile/') self.assertRedirects(response, '/auth/login/?next=/auth/user_profile/') def test_create_family_get(self): response = self.client.get('/auth/create_family/') self.assertEqual(response.status_code, 200) self.assertIn('form', response.context) def test_create_family_anonymous_user(self): self.client.logout() response = self.client.get('/auth/user_profile/') self.assertRedirects(response, '/auth/login/?next=/auth/user_profile/') def test_create_family_post(self): response = self.client.post('/auth/create_family/', data={'last_name': 'Samoilenko'}, follow=True) self.assertRedirects(response, '/auth/user_profile/') self.user.refresh_from_db() family = Family.objects.all().last() self.assertEqual(self.user.profile.family, family) self.assertTrue(self.user.profile.is_admin) self.assertContains(response, 'New Family was created.') def test_create_family_failed(self): family = Family.objects.create(last_name='Samoilenko') self.user.profile.family = family self.user.save() respose = self.client.post('/auth/create_family/', data={'last_name': 'TestTest'}, follow=True) self.assertRedirects(respose, '/auth/user_profile/') self.assertContains( respose, 'ou cannot create new Family as you belong to one.') def test_generate_token(self): family = Family.objects.create(last_name='Samoilenko') self.user.profile.family = family self.user.profile.is_admin = True self.user.save() response = self.client.get('/auth/create_token/') self.assertEqual(response.status_code, 200) self.assertIsInstance(response.content, bytes) def test_generate_token_failed(self): response = self.client.get('/auth/create_token/', follow=True) self.assertRedirects(response, '/auth/user_profile/') self.assertContains(response, 'Just Family admins can create the token.') family = Family.objects.create(last_name='Samoilenko') self.user.profile.family = family self.user.save() response = self.client.get('/auth/create_token/', follow=True) self.assertRedirects(response, '/auth/user_profile/') self.assertContains(response, 'Just Family admins can create the token.') def test_generate_token_anonymous(self): self.client.logout() response = self.client.get('/auth/create_token/', follow=True) self.assertRedirects(response, '/auth/login/?next=/auth/create_token/') def test_connect_to_family_success(self): family = Family.objects.create(last_name='Samoilenko') token = family.generate_token() response = self.client.post('/auth/connect_to_family/', data={'token': token}) self.assertRedirects(response, '/auth/user_profile/') self.user.refresh_from_db() self.assertEqual(self.user.profile.family, family) self.assertFalse(self.user.profile.is_admin) def test_connect_to_family_bag_token(self): response = self.client.post('/auth/connect_to_family/', data={}, follow=True) self.assertRedirects(response, '/auth/user_profile/') self.assertContains(response, 'Token cannot be empty.') response = self.client.post('/auth/connect_to_family/', data={'token': 'sdfghjk'}, follow=True) self.assertRedirects(response, '/auth/user_profile/') self.assertContains(response, 'Invalid token.') response = self.client.get('/auth/connect_to_family/') self.assertEqual(response.status_code, 405) def test_connect_to_family_have_family(self): family = Family.objects.create(last_name='Samoilenko') self.user.profile.family = family self.user.save() response = self.client.post('/auth/connect_to_family/', data={'token': family.generate_token()}, follow=True) self.assertRedirects(response, '/auth/user_profile/') self.assertContains(response, 'You cannot connect to another family.') def test_leave_family_success(self): family = Family.objects.create(last_name='Samoilenko') self.user.profile.family = family self.user.save() response = self.client.get('/auth/leave_family/') self.assertRedirects(response, '/auth/user_profile/') def test_leave_family_anonymous(self): self.client.logout() response = self.client.get('/auth/leave_family/', follow=True) self.assertRedirects(response, '/auth/login/?next=/auth/leave_family/') def test_leave_family_no_family(self): response = self.client.get('/auth/leave_family/', follow=True) self.assertRedirects(response, '/auth/user_profile/') self.assertContains(response, 'You do not belong to the Family') def test_leave_family_admin(self): family = Family.objects.create(last_name='Samoilenko') self.user.profile.family = family self.user.profile.is_admin = True self.user.save() response = self.client.get('/auth/leave_family/', follow=True) self.assertRedirects(response, '/auth/user_profile/') self.assertContains( response, 'Admin cannot leave the Family. Set up new admin first.')
class ViewTest_Concordia(TestCase): """ This class contains the unit tests for the view in the concordia app. Make sure the postgresql db is available. Run docker-compose up db """ def setUp(self): """ setUp is called before the execution of each test below :return: """ # make sure the config-optional-override.json mode is "unittest" self.assertEqual(Config.GetOverrideMode(), 'unittest') self.client = Client() def login_user(self): """ Create a user and log the user in :return: """ # create user and login self.user = User.objects.create(username='******', email='*****@*****.**') self.user.set_password('top_secret') self.user.save() login = self.client.login(username='******', password='******') def test_concordia_api(self): """ Test the tracribr_api. Provide a mock of requests :return: """ # Arrange relative_path = Mock() with patch('views.requests') as mock_requests: mock_requests.get.return_value = mock_response = Mock() mock_response.status_code = 200 mock_response.json.return_value = {'concordia_data': 'abc123456'} # Act results = views.concordia_api('relative_path') # Assert self.assertEqual(results['concordia_data'], 'abc123456') def test_AccountProfileView_get(self): """ Test the http GET on route account/profile :return: """ # Arrange self.login_user() # create a collection self.collection = Collection(title='TextCollection', slug='www.foo.com/slug2', description='Collection Description', metadata={"key": "val1"}, status=Status.PCT_0) self.collection.save() # create an Asset self.asset = Asset(title='TestAsset', slug='www.foo.com/slug1', description='Asset Description', media_url='http://www.foo.com/1/2/3', media_type=MediaType.IMAGE, collection=self.collection, metadata={"key": "val2"}, status=Status.PCT_0) self.asset.save() # add a Transcription object self.transcription = Transcription(asset=self.asset, user_id=self.user.id, status=Status.PCT_0) self.transcription.save() # Act response = self.client.get('/account/profile/') # Assert # validate the web page has the "tester" and "*****@*****.**" as values self.assertTrue('value="tester"' in str(response.content)) self.assertTrue('value="*****@*****.**"' in str(response.content)) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, template_name='profile.html') def test_AccountProfileView_post(self): """ This unit test tests the post entry for the route account/profile :param self: :return: """ # Arrange self.login_user() # Act response = self.client.post( '/account/profile/', { 'first_name': 'Jimmy', 'email': '*****@*****.**', 'username': '******', 'password1': '', 'password2': '' }) # Assert self.assertEqual(response.status_code, 302) self.assertEqual(response.url, '/account/profile/') # Verify the User was correctly updated updated_user = User.objects.get(id=self.user.id) self.assertEqual(updated_user.first_name, 'Jimmy') def test_AccountProfileView_post_invalid_form(self): """ This unit test tests the post entry for the route account/profile but submits an invalid form :param self: :return: """ # Arrange self.login_user() # Act response = self.client.post('/account/profile/', {'first_name': 'Jimmy'}) # Assert self.assertEqual(response.status_code, 302) self.assertEqual(response.url, '/account/profile/') # Verify the User was not changed updated_user = User.objects.get(id=self.user.id) self.assertEqual(updated_user.first_name, '') def test_AccountProfileView_post_new_password(self): """ This unit test test the post entry for the route account/profile with new password :param self: :return: """ # Arrange self.login_user() # Act response = self.client.post( '/account/profile/', { 'first_name': 'Jimmy', 'email': '*****@*****.**', 'username': '******', 'password1': 'abc', 'password2': 'abc' }) # Assert self.assertEqual(response.status_code, 302) self.assertEqual(response.url, '/account/profile/') # Verify the User was correctly updated updated_user = User.objects.get(id=self.user.id) self.assertEqual(updated_user.first_name, 'Jimmy') # logout and login with new password logout = self.client.logout() login2 = self.client.login(username='******', password='******') self.assertTrue(login2) def test_AccountProfileView_post_with_image(self): """ This unit test tests the post entry for the route account/profile with new image file :param self: :return: """ # Arrange self.login_user() existing_userprofile_count = UserProfile.objects.all().count() # Act image = Image.new('RGBA', size=(50, 50), color=(155, 0, 0)) file = tempfile.NamedTemporaryFile(suffix='.png') image.save(file) with open(file.name, encoding="ISO-8859-1") as fp: response = self.client.post( '/account/profile/', { 'myfile': fp, 'first_name': 'Jimmy', 'email': '*****@*****.**', 'username': '******', 'password1': '', 'password2': '' }) # Assert self.assertEqual(response.status_code, 302) self.assertEqual(response.url, '/account/profile/') # Verify the UserProfile was correctly updated, a new entry in db exists profile = UserProfile.objects.all() self.assertEqual(len(profile), existing_userprofile_count + 1) @patch('concordia.views.requests') def test_concordiaView(self, mock_requests): """ Test the GET method for route /transcribe :return: """ # Arrange mock_requests.get.return_value.status_code = 200 mock_requests.get.return_value.json.return_value = { 'concordia_data': 'abc123456' } # Act response = self.client.get('/transcribe/') # Assert self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, template_name='transcriptions/home.html') def test_concordiaCollectionView_get(self): """ Test GET on route /transcribe/<slug-value> (collection) :return: """ # Arrange # add an item to Collection self.collection = Collection(title='TextCollection', slug='test-slug2', description='Collection Description', metadata={"key": "val1"}, status=Status.PCT_0) self.collection.save() # Act response = self.client.get('/transcribe/test-slug2/') # Assert self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, template_name='transcriptions/collection.html') def test_concordiaCollectionView_get_page2(self): """ Test GET on route /transcribe/<slug-value>/ (collection) on page 2 :return: """ # Arrange # add an item to Collection self.collection = Collection(title='TextCollection', slug='test-slug2', description='Collection Description', metadata={"key": "val1"}, status=Status.PCT_0) self.collection.save() # Act response = self.client.get('/transcribe/test-slug2/', {'page': 2}) # Assert self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, template_name='transcriptions/collection.html') def test_ExportCollectionView_get(self): """ Test GET route /transcribe/export/<slug-value>/ (collection) :return: """ # Arrange self.collection = Collection(title='TextCollection', slug='slug2', description='Collection Description', metadata={"key": "val1"}, status=Status.PCT_0) self.collection.save() self.asset = Asset(title='TestAsset', slug='test-slug2', description='Asset Description', media_url='http://www.foo.com/1/2/3', media_type=MediaType.IMAGE, collection=self.collection, metadata={"key": "val2"}, status=Status.PCT_0) self.asset.save() # Act response = self.client.get('/transcribe/export/slug2/') # Assert self.assertEqual(response.status_code, 200) self.assertEqual( str(response.content), "b'Collection,Title,Description,MediaUrl,Transcription,Tags\\r\\nTextCollection,TestAsset,Asset Description,http://www.foo.com/1/2/3,,\\r\\n\'" ) def test_DeleteCollection_get(self): """ Test GET route /transcribe/delete/<slug-value>/ (collection) :return: """ # Arrange # add an item to Collection self.collection = Collection(title='TextCollection', slug='test-slug2', description='Collection Description', metadata={"key": "val1"}, status=Status.PCT_0) self.collection.save() self.asset = Asset(title='TestAsset', slug='test-slug2', description='Asset Description', media_url='http://www.foo.com/1/2/3', media_type=MediaType.IMAGE, collection=self.collection, metadata={"key": "val2"}, status=Status.PCT_0) self.asset.save() # Act response = self.client.get('/transcribe/delete/test-slug2', follow=True) # Assert self.assertEqual(response.status_code, 200) # verify the collection is not in db collection2 = Collection.objects.all() self.assertEqual(len(collection2), 0)
class TestProfile(TestCase): def setUp(self): self.client = Client() self.user1 = User.objects.create( username='******', password='******', email='*****@*****.**') self.user2 = User.objects.create( username='******', email='*****@*****.**') self.user2.set_password('pass@123') self.user2.save() self.user2_profile = Profile.objects.create( user=self.user2, department='Computer Engineering', institute='ace', position='instructor', phone_number='1122993388', is_email_verified=1 ) def test_has_profile_for_user_without_profile(self): """ If no profile exists for user passed as argument return False """ has_profile_status = has_profile(self.user1) self.assertFalse(has_profile_status) def test_has_profile_for_user_with_profile(self): """ If profile exists for user passed as argument return True """ has_profile_status = has_profile(self.user2) self.assertTrue(has_profile_status) def test_view_profile_denies_anonymous(self): """ If not logged in redirect to login page """ response = self.client.get(reverse(view_profile), follow=True) redirect_destination = '/login/?next=/view_profile/' self.assertTrue(response.status_code,200) self.assertRedirects(response, redirect_destination) def test_edit_profile_get(self): """ GET request to edit profile should display profile form """ self.client.login(username=self.user2, password='******') response = self.client.get(reverse(edit_profile)) user_profile = User.objects.get(id=self.user2.id) profile = Profile.objects.get(user=user_profile) self.assertEqual(response.status_code, 200) self.assertEqual(profile.institute, 'ace') self.client.logout() def test_edit_profile_post(self): self.client.login(username=self.user2, password='******') response = self.client.post('/edit_profile/', { 'first_name': 'demo_test', 'last_name': 'user2', 'institute': 'IIT', 'department': 'aerospace engineering' }) updated_profile_user = User.objects.get(id=self.user2.id) updated_profile = Profile.objects.get(user=updated_profile_user) self.assertEqual(updated_profile.institute, 'IIT') self.assertEqual(updated_profile.department, 'aerospace engineering') self.assertEqual(updated_profile.position, 'instructor') self.assertEqual(response.status_code, 200) # self.assertTemplateUsed(response, 'workshop_app/profile_updated.html') def test_register_page(self): self.client.get('/register/') self.register_response = self.client.post('/register/', data={ 'username':'******', 'email':'*****@*****.**', 'password':'******', 'confirm password':'******', 'first name':'testor', 'last name':'user', 'phone number': 1234567890, 'institute':'IIT', 'department':(2)}) self.assertEqual(self.register_response.status_code,200)
class TemplateTestCase(TestCase): def setUp(self): self.client = Client() devGroup = Group.objects.create(name='Developer') cusGroup = Group.objects.create(name='Customer') userDeveloper = User.objects.create_user('developer', '*****@*****.**', 'developer') userCustomer = User.objects.create_user('customer', '*****@*****.**', 'customer') devProfile = UserProfile.objects.create(user=userDeveloper, isDeveloper=True, username='******') UserProfile.objects.create(user=userCustomer, isDeveloper=False, username='******') Game.objects.create(name='Test Game', price=0.99, url='www.google.fi', published=timezone.now(), description='Test Description', developer=devProfile) devGroup.user_set.add(userDeveloper) cusGroup.user_set.add(userCustomer) def testLogin(self): """ Check that temp users work """ self.client.login(username='******', password='******') devUser = User.objects.get(username='******') profile = UserProfile.objects.get(user=devUser) print('\nDeveloper correctly set up:', end=" ") print(profile.isDeveloper) self.client.logout() def testInvalidUrls(self): """ Test for invalid urls """ print('Testing invalid urls') res = self.client.get('/game/xx') self.assertEquals(res.status_code, 404, "Requesting a game page with an invalid code.") res = self.client.get('/dev/xx') self.assertEquals(res.status_code, 404, "Requesting a developer page with an invalid code.") res = self.client.get('/dev/game/xx') self.assertEquals( res.status_code, 404, "Requesting a game editing page with an invalid code.") res = self.client.get('/xx') self.assertEquals(res.status_code, 404, "Requesting a page with an invalid code.") def testGameMenu(self): """ Tests that the game list is rendered correctly """ print('Testing gamelist') all_games = ({ 'name': 'testGame', 'description': 'testScription', 'price': 0.99 }, { 'name': 'bestGame', 'description': 'badScription', 'price': 1.99 }) ren = render_to_string("webshop/gamelist.html", {'all_games': all_games}) for game in all_games: self.assertTrue( ren.find(game['name']) > -1, "Testing if the rendered menu contains correct game name") self.assertTrue( ren.find(game['description']) > -1, "Testing if the rendered menu contains correct game description" ) self.assertTrue( ren.find(str(game['price'])) > -1, "Testing if the rendered menu contains correct game price") def testBuyGame(self): """ Test buying game by accessing /buy/success """ print('\nTesting access to /buy/success') # No user self.client.logout() res = self.client.get('/buy/success/1') self.assertTemplateUsed(res, 'webshop/buy_error.html') # With user self.client.login(username='******', password='******') res = self.client.get('/buy/success/1') self.assertTemplateUsed(res, 'webshop/buy_error.html') self.client.logout()
class FollowAndCommentView(TestCase): def setUp(self): self.client = Client() self.user_follower = User.objects.create_user(username='******', password='******') self.client.force_login(self.user_follower) self.user_wo_subscribe = User.objects.create_user( username='******', password='******') self.user_for_subscribe = User.objects.create_user( username='******', password='******') self.group = Group.objects.create(title='test_group', slug='test_group', description='test_group') def test_user_subscribe_and_unsubscribe_author(self): self.client.post( reverse('profile_follow', kwargs={'username': self.user_for_subscribe})) self.assertEquals(Follow.objects.count(), 1) subscribed_author = Follow.objects.get(user=self.user_follower) self.assertEquals(subscribed_author.author, self.user_for_subscribe) def test_user_unsubscribe_author(self): self.client.post( reverse('profile_follow', kwargs={'username': self.user_for_subscribe})) self.assertEquals(Follow.objects.count(), 1) self.client.post( reverse('profile_unfollow', kwargs={'username': self.user_for_subscribe})) self.assertEquals(Follow.objects.count(), 0) @override_settings(CACHES=DUMMY_CACHE) def test_posts_subscribed_user(self): text = 'following_text' self.client.force_login(self.user_for_subscribe) self.client.post(reverse('new_post'), data={ 'group': self.group.id, 'text': text }, follow=True) self.client.force_login(self.user_follower) self.client.post( reverse('profile_follow', kwargs={'username': self.user_for_subscribe})) resp_subscribed = self.client.get(reverse('follow_index')) self.assertEquals(resp_subscribed.context['paginator'].count, 1) self.assertContains(resp_subscribed, text) def test_nonsubscribed_user_posts(self): text = 'following_text' self.client.force_login(self.user_for_subscribe) self.client.post(reverse('new_post'), data={ 'group': self.group.id, 'text': text }, follow=True) self.client.force_login(self.user_wo_subscribe) resp_nonsubscribed = self.client.get(reverse('follow_index')) self.assertEquals(resp_nonsubscribed.context['paginator'].count, 0) def test_subscribe_by_itself(self): resp_tag = self.client.get( reverse('profile', kwargs={'username': self.user_follower.username})) self.assertNotContains(resp_tag, 'Подписаться') self.assertNotContains(resp_tag, 'Отписаться') def test_auth_user_add_comment(self): text_comment = 'text for comment' text = 'following_text' self.client.force_login(self.user_for_subscribe) self.client.post(reverse('new_post'), data={ 'group': self.group.id, 'text': text }, follow=True) self.client.force_login(self.user_follower) post = Post.objects.get(author=self.user_for_subscribe) self.client.post(reverse('add_comment', kwargs={ 'username': self.user_for_subscribe, 'post_id': post.id }), data={'text': text_comment}, follow=True) comment = Comment.objects.get(author=self.user_follower) self.assertEquals(Comment.objects.count(), 1) self.assertEquals(comment.text, text_comment) self.assertEquals(comment.post.text, post.text) resp = self.client.get( reverse('post', kwargs={ 'username': self.user_for_subscribe, 'post_id': post.id })) self.assertEquals(resp.context['comments'][0].text, text_comment) def test_non_auth_user_add_comment(self): text = 'following_text' self.client.force_login(self.user_for_subscribe) self.client.post(reverse('new_post'), data={ 'group': self.group.id, 'text': text }, follow=True) self.client.logout() text_comment = 'text for comment' post = Post.objects.get(author=self.user_for_subscribe) self.client.post(reverse('add_comment', kwargs={ 'username': self.user_for_subscribe, 'post_id': post.id }), data={'text': text_comment}, follow=True) comments_count = Comment.objects.count() self.assertEquals(comments_count, 0)
class AuthUserPostView(TestCase): def setUp(self): self.client = Client() self.user = User.objects.create_user(username='******', password='******') self.client.force_login(self.user) self.group = Group.objects.create(title='test_group', slug='test_group', description='test_group') def test_create_new_user_and_profile(self): resp = self.client.get( reverse('profile', kwargs={'username': self.user.username})) self.assertEqual(resp.status_code, 200) self.assertTemplateUsed(resp, 'profile.html') def test_logged_user_make_create_post(self): text = 'text for post' self.client.post(reverse('new_post'), data={ 'group': self.group.id, 'text': text }, follow=True) post = Post.objects.first() self.assertEquals(Post.objects.count(), 1) self.assertEquals(post.author, self.user) self.assertEquals(post.group, self.group) self.assertEquals(post.text, text) def test_view_post_on_all_templates(self): text = 'text for post' self.post = Post.objects.create(author=self.user, group=self.group, text=text) urls = [ reverse('index'), reverse('profile', kwargs={'username': self.user.username}), reverse('post', kwargs={ 'username': self.user.username, 'post_id': self.post.id }), reverse('group', kwargs={'slug': self.group.slug}) ] for url in urls: with self.subTest(url=url): self.check_post_on_templates(url=url, author=self.user, group=self.group, text=text) def test_logged_user_edit_post(self): text = 'text for post' new_text = 'new text' new_group = Group.objects.create(title='new_group', slug='new_group', description='new_group') self.post = Post.objects.create(author=self.user, group=self.group, text=text) self.client.post(reverse('post_edit', kwargs={ 'username': self.user, 'post_id': self.post.id }), data={ 'group': new_group.id, 'text': new_text }, follow=True) resp_old_group = self.client.get( reverse('group', kwargs={'slug': self.group})) self.assertEquals(resp_old_group.context['paginator'].count, 0) urls = [ reverse('index'), reverse('profile', kwargs={'username': self.user.username}), reverse('post', kwargs={ 'username': self.user.username, 'post_id': self.post.id }), reverse('group', kwargs={'slug': new_group.slug}) ] for url in urls: with self.subTest(url=url): self.check_post_on_templates(url=url, author=self.user, group=new_group, text=new_text) def check_post_on_templates(self, url, author, group, text): resp = self.client.get(url) if 'paginator' in resp.context: self.assertEquals(resp.context['paginator'].count, 1) post = resp.context['page'][0] else: post = resp.context['post'] self.assertEquals(post.text, text) self.assertEquals(post.author, author) self.assertEquals(post.group, group) def test_redirect_if_not_logged_user_try_create_post(self): self.client.logout() resp = self.client.get(reverse('new_post'), follow=True) self.assertRedirects(resp, '/auth/login/?next=/new/') def test_error_404(self): resp = self.client.get('/404/') self.assertEquals(resp.status_code, 404) self.assertTemplateUsed(resp, 'misc/404.html') @override_settings(CACHES=DUMMY_CACHE) def test_tag_on_post_template(self): io_image = BytesIO() generated_image = Image.new(mode='RGBA', size=(100, 100)) generated_image.save(io_image, 'png') io_image.seek(0) data = { 'group': self.group.id, 'text': 'new_text', 'image': ImageFile(io_image, 'image.png') } self.client.post(reverse('new_post'), data=data, follow=True) urls = [ reverse('index'), reverse('post', kwargs={ 'username': self.user.username, 'post_id': 1 }), reverse('profile', kwargs={'username': self.user.username}), reverse('group', kwargs={'slug': self.group.slug}) ] for url in urls: with self.subTest(url=url): resp = self.client.get(url) self.assertContains(resp, '<img') def test_form_image_field_validation(self): txt_file = SimpleUploadedFile('file.txt', b'text_file') resp = self.client.post(reverse('new_post'), data={ 'group': self.group.id, 'image': txt_file }, follow=True) error = 'Загрузите правильное изображение. Файл, который вы загрузили, поврежден или не является изображением.' self.assertFormError(resp, 'form', 'image', error) def test_cache_index_posts(self): text_new_post = 'text for post' text_after_edit = 'new text' post = Post.objects.create(author=self.user, group=self.group, text=text_new_post) self.check_version_template_in_cache(text=text_new_post) self.client.post(reverse('post_edit', kwargs={ 'username': self.user, 'post_id': post.id }), data={ 'group': self.group.id, 'text': text_after_edit }, follow=True) self.check_version_template_in_cache(text=text_new_post) response = self.client.get(reverse('index')) key = make_template_fragment_key('index_page', [response.context['page'].number]) cache.delete(key) self.check_version_template_in_cache(text=text_after_edit) def check_version_template_in_cache(self, text): resp = self.client.get(reverse('index')) self.assertContains(resp, text)
class TicketViewsTestCase(TestCase): def setUp(self): self.client = Client() self.plane = Plane.objects.create(name="A333") self.flight = Flight.objects.create(departure_time=timezone.now(), flight_id="AV 2341", country="Russia", city="Moscow", arrival_time=timezone.now(), company="S7", plane_name=self.plane, status="Registration") self.user = User.objects.create_user(username='******', password='******') self.ticket = Ticket.objects.create(user=self.user, flight=self.flight) self.client.login(username='******', password='******') def test_flight_ticket_GET(self): response = self.client.get( reverse('flight_ticket_url', kwargs={'slug': self.flight.slug})) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'crm/ticket_booking.html') def test_flight_ticket_GET_flight_not_flight(self): response = self.client.get( reverse('flight_ticket_url', kwargs={'slug': 'test_slug'})) self.assertEqual(response.status_code, 404) def test_flight_ticket_GET_without_slug(self): response = self.client.get( reverse('flight_ticket_url', kwargs={'slug': None})) self.assertEqual(response.status_code, 404) def test_flight_ticket_POST(self): response = self.client.post( reverse('flight_ticket_url', kwargs={'slug': self.flight.slug})) posted_ticket = Ticket.objects.all()[1] self.assertEqual(response.status_code, 302) self.assertEqual(posted_ticket.user, self.user) self.assertEqual(posted_ticket.flight, self.flight) def test_flight_ticket_POST_flight_not_found(self): response = self.client.post( reverse('flight_ticket_url', kwargs={'slug': 'test_slug'})) self.assertEqual(response.status_code, 404) def test_flight_ticket_POST_without_slug(self): response = self.client.post( reverse('flight_ticket_url', kwargs={'slug': None})) self.assertEqual(response.status_code, 404) def test_flight_ticket_POST_as_anonymous_user(self): self.client.logout() response = self.client.post( reverse('flight_ticket_url', kwargs={'slug': self.flight.slug})) self.assertEqual(response.status_code, 400) def test_flight_ticket_delete_GET(self): response = self.client.get( reverse('flight_ticket_delete_url', kwargs={'slug': self.flight.slug})) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'crm/ticket_delete.html') def test_flight_ticket_delete_GET_flight_not_found(self): response = self.client.get( reverse('flight_ticket_delete_url', kwargs={'slug': 'test_slug'})) self.assertEqual(response.status_code, 404) def test_flight_ticket_delete_GET_without_slug(self): response = self.client.get( reverse('flight_ticket_delete_url', kwargs={'slug': None})) self.assertEqual(response.status_code, 404) def test_flight_ticket_delete_POST(self): response = self.client.post( reverse('flight_ticket_delete_url', kwargs={'slug': self.flight.slug})) tickets_count = Ticket.objects.all().count() self.assertEqual(response.status_code, 302) self.assertEqual(tickets_count, 0) def test_flight_ticket_delete_POST_flight_not_found(self): response = self.client.post( reverse('flight_ticket_delete_url', kwargs={'slug': 'test_slug'})) self.assertEqual(response.status_code, 404) def test_flight_ticket_delete_POST_without_slug(self): response = self.client.post( reverse('flight_ticket_delete_url', kwargs={'slug': None})) self.assertEqual(response.status_code, 404) def test_flight_ticket_delete_POST_as_anonymous_user(self): self.client.logout() response = self.client.post( reverse('flight_ticket_delete_url', kwargs={'slug': self.flight.slug})) self.assertEqual(response.status_code, 400) def test_my_tickets_GET(self): response = self.client.get(reverse('my_tickets_url')) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'crm/my_tickets.html') def test_my_tickets_GET_as_anonymous_user(self): self.client.logout() response = self.client.get(reverse('my_tickets_url')) self.assertEqual(response.status_code, 400)
class PluginsMenuTest(TestCase): def setUp(self): self.user = self.create_user() self.client = Client() cache.clear() def tearDown(self): cache.clear() self.client.logout() def create_user(self): user = User() user.username = "******" user.set_password("123colab4") user.email = "*****@*****.**" user.id = 1 user.first_name = "USERtestCoLaB" user.last_name = "COLAB" user.save() return user def authenticate_user(self): self.client.login(username=self.user.username, password="******") def test_plugins_menu_without_menu_urls(self): self.authenticate_user() plugin_1 = {'menu_title': 'myTitle', 'menu_urls': []} test_context = {'user': self.user, 'plugins': {'plugin_1': plugin_1}} menu = plugins.plugins_menu(test_context) self.assertEquals(menu.strip(), "") def test_plugins_menu_with_1_menu_urls(self): self.authenticate_user() link = 'http://url' title = 'myTitle' plugin_1 = {'menu_title': title, 'menu_urls': [{'url': link, 'display': 'LRU'}]} test_context = {'user': self.user, 'plugins': {'plugin_1': plugin_1}} menu = plugins.plugins_menu(test_context) self.assertIn(link, menu) self.assertIn(title, menu) def test_plugins_menu_with_many_menu_urls(self): self.authenticate_user() link1 = 'http://url1' title1 = 'myTitle1' display1 = 'LRU1' link2 = 'http://url2' display2 = 'LRU2' plugin_1 = {'menu_title': title1, 'menu_urls': [{'url': link1, 'display': display1}, {'url': link2, 'display': display2}]} test_context = {'user': self.user, 'plugins': {'plugin_1': plugin_1}} menu = plugins.plugins_menu(test_context) self.assertIn(link1, menu) self.assertIn(title1, menu) self.assertIn(display1, menu) self.assertIn(link2, menu) self.assertIn(display2, menu) def test_plugins_menu_with_multiple_plugins(self): self.authenticate_user() link1 = 'http://url1' title1 = 'myTitle1' display1 = 'LRU1' link2 = 'http://url2' display2 = 'LRU2' plugin_1 = {'menu_title': title1, 'menu_urls': [{'url': link1, 'display': display1}, {'url': link2, 'display': display2}]} title2 = 'myTitle2' plugin_2 = {'menu_title': title2, 'menu_urls': []} test_context = {'user': self.user, 'plugins': {'plugin_1': plugin_1, 'plugin_2': plugin_2}} menu = plugins.plugins_menu(test_context) self.assertIn(link1, menu) self.assertIn(title1, menu) self.assertIn(display1, menu) self.assertIn(link2, menu) self.assertIn(display2, menu) self.assertNotIn(title2, menu) class ColabUrlMock(Mock): def auth(self): return True def test_plugins_menu_with_inactivate_user(self): self.user.is_active = False self.user.save() self.authenticate_user() title = 'myTitle' plugin_1 = {'menu_title': title, 'menu_urls': [self.ColabUrlMock()]} test_context = {'user': self.user, 'plugins': {'plugin_1': plugin_1}} menu = plugins.plugins_menu(test_context) self.assertEquals("", menu.strip())
class PageTest(TestCase, CommonFunc): def setUp(self): self.user = User.objects.create_user(username="******") self.auth_client = Client() self.auth_client.force_login(self.user) self.non_auth_client = Client() self.group = Group.objects.create( title="test group", slug="test-slug", description="description", ) def test_client_page(self): """ Тест проверяет, что осле регистрации пользователя создается его персональная страница (profile) """ response = self.auth_client.get( reverse("profile", kwargs={"username": self.user.username}) ) self.assertEqual(response.status_code, 200, "Страница пользователя не найдена!") def test_create_post_by_auth_user(self): """ Тест проверяет, что авторизованный пользователь может опубликовать пост (new) """ response = self.auth_client.post( reverse("new_post"), data={"group": self.group.id, "text": "test"}, follow=True, ) self.assertEqual(response.status_code, 200, "Ошибка создания поста!") created_post = Post.objects.all().first() self.assertEqual(Post.objects.count(), 1) self.assertEqual(created_post.group, self.group) self.assertEqual(created_post.author, self.user) self.assertEqual(created_post.text, "test") def test_create_post_by_non_auth_user(self): """ Тест проверяет, что НЕ авторизованный пользователь НЕ может опубликовать пост (new) """ self.non_auth_client.logout() response = self.non_auth_client.get(reverse("new_post")) self.assertRedirects( response, "/auth/login/?next=/new/", msg_prefix="Не авторизованный пользователь" "не переадресовывается на страницу " "входа (login)!", ) def test_post_exists_on_pages(self): """ Тест создает пост и проверяет его отображение по всем страницам из спискка urls_list """ text = "text in test post" post = Post.objects.create(text=text, author=self.user, group=self.group) urls_list = [ reverse("index"), reverse("profile", kwargs={"username": self.user.username}), reverse( "post", kwargs={"username": self.user.username, "post_id": post.id} ), ] for url in urls_list: with self.subTest(url=url): self.check_post_on_page( self.auth_client, url, text, self.user, self.group ) def test_auth_user_can_edit_own_post(self): """ Тест проверяет, что авторизованный пользователь может отредактировать свой пост и его содержимое изменится на всех связанных страницах """ post = Post.objects.create( text="old text in post", author=self.user, group=self.group ) edit_urls_list = [ reverse("index"), reverse("profile", kwargs={"username": self.user.username}), reverse( "post", kwargs={"username": self.user.username, "post_id": post.id} ), ] new_text = "This is text after edit." response = self.auth_client.post( reverse( "post_edit", kwargs={"post_id": post.id, "username": self.user.username} ), data={"group": self.group.id, "text": new_text}, follow=True, ) self.assertEqual(response.status_code, 200) for url in edit_urls_list: with self.subTest(url=url): self.check_post_on_page( self.auth_client, url, new_text, self.user, self.group ) def test_404(self): response = self.auth_client.get("/unknown/") self.assertEqual( response.status_code, 404, "Страница '/unknown/' существует " " проверьте ошибку 404 на другой странице!", ) def _create_image(self): with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f: image = Image.new("RGB", (200, 200), "white") image.save(f, "PNG") return open(f.name, mode="rb") def test_image(self): post = Post.objects.create( text="post with image", author=self.user, group=self.group ) img_urls_list = [ reverse("index"), reverse("profile", kwargs={"username": self.user.username}), reverse( "post", kwargs={"username": self.user.username, "post_id": post.id} ), reverse("group", kwargs={"slug": self.group.slug}), ] img = self._create_image() response = self.auth_client.post( reverse( "post_edit", kwargs={"post_id": post.id, "username": self.user.username}, ), data={"group": self.group.id, "text": "post with image", "image": img}, follow=True, ) self.assertEqual(response.status_code, 200, "Ошибка добавления картинки!") for url in img_urls_list: with self.subTest(url=url): response = self.auth_client.get(url) self.assertEqual( response.status_code, 200, "Не найдена страница с картинкой!" ) self.assertContains(response, "<img") def test_wrong_image(self): post = Post.objects.create( text="post with bad image", author=self.user, group=self.group ) file = SimpleUploadedFile("filename.txt", b"hello world", "text/plain") response = self.auth_client.post( reverse( "post_edit", kwargs={"post_id": post.id, "username": self.user.username}, ), data={"group": self.group.id, "text": "post with bad image", "image": file}, follow=True, ) self.assertEqual(response.status_code, 200) self.assertFormError( response, "form", "image", "Загрузите правильное изображение. Файл, который вы загрузили, поврежден или не является изображением.", )
class ProposalTest(TestCase): fixtures = ['user.json', 'socialapp.json'] def setUp(self): self.client = Client() self.event = Event.objects.create(**EVENT_DATA) self.proposal_data = PROPOSAL_DATA.copy() self.proposal_data.update(event=self.event) self.proposal = Proposal.objects.create(**self.proposal_data) self.client.login(username='******', password='******') def test_empty_list_proposal(self): self.proposal.delete() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], []) def test_list_proposal(self): self.client.logout() self.client.login(username='******', password='******') response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) # Starts Admin Overview def test_list_proposal_as_admin_user(self): self.client.login(username='******', password='******') response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) def test_list_proposal_without_public_voting_as_admin_user(self): self.client.login(username='******', password='******') self.event.allow_public_voting = False self.event.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) def test_list_proposal_without_published_and_as_admin_user(self): self.client.login(username='******', password='******') self.event.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) def test_list_proposal_without_public_voting_and_without_published_and_as_admin_user(self): self.client.login(username='******', password='******') self.event.allow_public_voting = False self.event.save() self.proposal.is_published = False self.proposal.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) # Ends Admin Overview # Starts Author Overview def test_list_proposal_as_author(self): self.client.logout() self.client.login(username='******', password='******') self.event.author = User.objects.get(username='******') self.event.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) def test_list_proposal_without_public_voting_as_author(self): self.client.logout() self.client.login(username='******', password='******') self.event.author = User.objects.get(username='******') self.event.allow_public_voting = False self.event.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) def test_list_proposal_without_published_and_as_author(self): self.client.logout() self.client.login(username='******', password='******') self.event.author = User.objects.get(username='******') self.event.save() self.proposal.is_published = False self.proposal.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) def test_list_proposal_without_public_voting_and_without_published_and_as_author(self): self.client.logout() self.client.login(username='******', password='******') self.event.author = User.objects.get(username='******') self.event.allow_public_voting = False self.event.save() self.proposal.is_published = False self.proposal.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) # Ends Author Overview # Starts User Overview def test_list_proposal_as_user(self): response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ['<Proposal: Python For Zombies>']) def test_list_proposal_without_public_voting_as_user(self): self.event.allow_public_voting = False self.event.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], []) def test_list_proposal_without_published_and_as_user(self): self.proposal.is_published = False self.proposal.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ['<Proposal: Python For Zombies>']) def test_list_proposal_without_public_voting_and_without_published_and_as_user(self): self.event.allow_public_voting = False self.event.save() self.proposal.is_published = False self.proposal.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], []) # Ends User Overview def test_list_proposal_without_logged_user(self): self.client.logout() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ['<Proposal: Python For Zombies>']) def test_list_proposal_without_public_voting(self): self.client.logout() self.client.login(username='******', password='******') self.event.allow_public_voting = False self.event.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], []) def test_list_proposal_without_public_voting_and_without_logged_user(self): self.client.logout() self.event.allow_public_voting = False self.event.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], []) def test_list_proposal_with_public_voting(self): self.client.logout() self.client.login(username='******', password='******') self.event.allow_public_voting = True self.event.save() self.proposal.is_published = True self.proposal.save() response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>"]) def test_list_proposal_ordering_when_user_is_logged(self): another_proposal_data = ANOTHER_PROPOSAL_DATA.copy() another_proposal_data.update(event=self.event) another_proposal = Proposal.objects.create(**another_proposal_data) response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: A Python 3 Metaprogramming Tutorial>", "<Proposal: Python For Zombies>"]) rate_proposal_data = { 'event_slug': another_proposal.event.slug, 'slug': another_proposal.slug, 'rate': 'laughing' } self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) response = self.client.get( reverse('view_event', kwargs={'slug': self.event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_proposals'], ["<Proposal: Python For Zombies>", "<Proposal: A Python 3 Metaprogramming Tutorial>"]) def test_update_proposal(self): new_proposal_data = self.proposal_data.copy() new_proposal_data['description'] = 'A really really good proposal.' self.assertEquals(self.proposal_data['description'], self.proposal.description) response = self.client.get( reverse('update_proposal', kwargs={'event_slug': self.event.slug, 'slug': self.proposal.slug})) self.assertEqual(response.context['event'], self.event) response = self.client.post( reverse('update_proposal', kwargs={'event_slug': self.event.slug, 'slug': self.proposal.slug}), new_proposal_data, follow=True) self.assertEquals(200, response.status_code) self.proposal = response.context['event'].proposals.first() self.assertEquals('Python For Zombies', self.proposal.title) self.assertEquals('A really really good proposal.', self.proposal.description) def test_anonymous_user_update_proposal(self): self.client.logout() new_proposal_data = self.proposal_data.copy() new_proposal_data['description'] = 'A really really good proposal.' proposal_update_url = reverse( 'update_proposal', kwargs={'event_slug': self.event.slug, 'slug': self.proposal.slug}) response = self.client.post( proposal_update_url, new_proposal_data, follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(proposal_update_url, response.context_data.get('redirect_field_value')) self.assertEquals('Brain...', self.proposal.description) def test_delete_proposal(self): new_proposal_data = self.proposal_data.copy() new_proposal_data['author_id'] = User.objects.get(username='******').id new_proposal_data['description'] = 'A good candidate to be deleted.' proposal = Proposal.objects.create(**new_proposal_data) self.assertEqual( Proposal.objects.filter(slug=proposal.slug).count(), 1) response = self.client.post( reverse('delete_proposal', kwargs={'event_slug': proposal.event.slug, 'slug': proposal.slug}), follow=True) self.assertEqual(response.status_code, 200) self.assertContains(response, 'Proposal deleted.') self.assertEqual( Proposal.objects.filter(slug=proposal.slug).count(), 0) def test_not_allowed_to_delete_proposal(self): response = self.client.post( reverse('delete_proposal', kwargs={'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug}), follow=True) self.assertEqual(200, response.status_code) self.assertContains(response, 'You are not allowed to see this page.') def test_rate_proposal(self): rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'laughing' } response = self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(1, Vote.objects.count()) self.assertEquals(1, self.proposal.votes.count()) self.assertEquals(3, self.proposal.get_rate) def test_rate_proposal_by_get(self): rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'laughing' } response = self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(1, Vote.objects.count()) self.assertEquals(1, self.proposal.votes.count()) self.assertEquals(3, self.proposal.get_rate) def test_rate_proposal_in_a_disallowed_event(self): self.client.logout() self.client.login(username='******', password='******') self.event.allow_public_voting = False self.event.save() rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(401, response.status_code) self.assertEquals(0, self.proposal.get_rate) self.assertEquals(0, self.proposal.votes.count()) self.assertEquals(0, Vote.objects.count()) def test_rate_proposal_in_a_disallowed_event_by_get(self): self.client.logout() self.client.login(username='******', password='******') self.event.allow_public_voting = False self.event.save() rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(0, self.proposal.get_rate) self.assertEquals(0, self.proposal.votes.count()) self.assertEquals(0, Vote.objects.count()) def test_rate_proposal_overrated_value(self): rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'whatever' } response = self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(400, response.status_code) self.assertIn('message', json.loads(response.content)) self.assertEquals(0, self.proposal.get_rate) self.assertEquals(0, self.proposal.votes.count()) self.assertEquals(0, Vote.objects.count()) def test_rate_proposal_overrated_value_by_get(self): rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'whatever' } response = self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(0, self.proposal.get_rate) self.assertEquals(0, self.proposal.votes.count()) self.assertEquals(0, Vote.objects.count()) def test_rate_proposal_multiple_times(self): rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'laughing' } self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) rate_proposal_data.update({'rate': 'happy'}) response = self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(401, response.status_code) self.assertEquals(1, Vote.objects.count()) self.assertEquals(1, self.proposal.votes.count()) self.assertEquals(3, self.proposal.get_rate) def test_rate_proposal_multiple_times_by_get(self): rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'laughing' } self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) rate_proposal_data.update({'rate': 'happy'}) response = self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(1, Vote.objects.count()) self.assertEquals(1, self.proposal.votes.count()) self.assertEquals(3, self.proposal.get_rate) def test_rate_proposal_with_the_same_author(self): self.client.logout() self.client.login(username='******', password='******') self.proposal.author = User.objects.get(username='******') self.proposal.save() rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(401, response.status_code) self.assertEquals(0, self.proposal.get_rate) self.assertEquals(0, self.proposal.votes.count()) self.assertEquals(0, Vote.objects.count()) def test_rate_proposal_with_the_same_author_by_get(self): self.client.logout() self.client.login(username='******', password='******') self.proposal.author = User.objects.get(username='******') self.proposal.save() rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(0, self.proposal.get_rate) self.assertEquals(0, self.proposal.votes.count()) self.assertEquals(0, Vote.objects.count()) def test_anonymous_user_rate_proposal(self): self.client.logout() rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(401, response.status_code) self.assertIn('message', json.loads(response.content)) self.assertEquals(0, self.proposal.get_rate) self.assertEquals(0, self.proposal.votes.count()) self.assertEquals(0, Vote.objects.count()) def test_anonymous_user_rate_proposal_by_get(self): self.client.logout() rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(0, self.proposal.get_rate) self.assertEquals(0, self.proposal.votes.count()) self.assertEquals(0, Vote.objects.count()) def test_rate_proposal_with_the_admin_user(self): self.client.logout() self.client.login(username='******', password='******') self.proposal.author = User.objects.get(username='******') self.proposal.save() rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(1, self.proposal.get_rate) self.assertEquals(1, self.proposal.votes.count()) self.assertEquals(1, Vote.objects.count()) def test_rate_proposal_with_the_admin_user_by_get(self): self.client.logout() self.client.login(username='******', password='******') self.proposal.author = User.objects.get(username='******') self.proposal.save() rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(1, self.proposal.get_rate) self.assertEquals(1, self.proposal.votes.count()) self.assertEquals(1, Vote.objects.count()) def test_rate_proposal_with_the_jury_user(self): self.event.jury.users.add(User.objects.get(username='******')) self.client.logout() self.client.login(username='******', password='******') rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.post( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(1, self.proposal.get_rate) self.assertEquals(1, self.proposal.votes.count()) self.assertEquals(1, Vote.objects.count()) def test_rate_proposal_with_the_jury_user_by_get(self): self.event.jury.users.add(User.objects.get(username='******')) self.client.logout() self.client.login(username='******', password='******') rate_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, 'rate': 'sad' } response = self.client.get( reverse('rate_proposal', kwargs=rate_proposal_data), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(1, self.proposal.get_rate) self.assertEquals(1, self.proposal.votes.count()) self.assertEquals(1, Vote.objects.count()) def test_approve_proposal_with_the_anonymous_user(self): self.client.logout() approve_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, } response = self.client.post( reverse('approve_proposal', kwargs=approve_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(401, response.status_code) self.assertIn('message', json.loads(response.content)) self.assertEquals(False, self.proposal.is_approved) def test_approve_proposal_with_the_admin_user(self): self.client.logout() self.client.login(username='******', password='******') self.proposal.author = User.objects.get(username='******') self.proposal.save() approve_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, } response = self.client.post( reverse('approve_proposal', kwargs=approve_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(200, response.status_code) self.assertIn('message', json.loads(response.content)) self.assertEquals(True, self.proposal.is_approved) def test_approve_proposal_with_the_admin_user_by_get(self): self.client.logout() self.client.login(username='******', password='******') self.proposal.author = User.objects.get(username='******') self.proposal.save() approve_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug } response = self.client.get( reverse('approve_proposal', kwargs=approve_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(200, response.status_code) self.assertEquals(True, self.proposal.is_approved) def test_approve_proposal_with_the_jury_user(self): self.event.jury.users.add(User.objects.get(username='******')) self.client.logout() self.client.login(username='******', password='******') approve_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug } response = self.client.post( reverse('approve_proposal', kwargs=approve_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(200, response.status_code) self.assertIn('message', json.loads(response.content)) self.assertEquals(True, self.proposal.is_approved) def test_approve_proposal_with_the_jury_user_by_get(self): self.event.jury.users.add(User.objects.get(username='******')) self.client.logout() self.client.login(username='******', password='******') approve_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug } response = self.client.get( reverse('approve_proposal', kwargs=approve_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(200, response.status_code) self.assertEquals(True, self.proposal.is_approved) def test_disapprove_proposal_with_the_anonymous_user(self): self.proposal.is_approved = True self.proposal.save() self.client.logout() disapprove_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, } response = self.client.post( reverse('disapprove_proposal', kwargs=disapprove_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(401, response.status_code) self.assertIn('message', json.loads(response.content)) self.assertEquals(True, self.proposal.is_approved) def test_disapprove_proposal_with_the_admin_user(self): self.client.logout() self.client.login(username='******', password='******') self.proposal.author = User.objects.get(username='******') self.proposal.is_approved = True self.proposal.save() disapprove_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug, } response = self.client.post( reverse('disapprove_proposal', kwargs=disapprove_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(200, response.status_code) self.assertIn('message', json.loads(response.content)) self.assertEquals(False, self.proposal.is_approved) def test_disapprove_proposal_with_the_admin_user_by_get(self): self.client.logout() self.client.login(username='******', password='******') self.proposal.author = User.objects.get(username='******') self.proposal.is_approved = True self.proposal.save() disapprove_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug } response = self.client.get( reverse('disapprove_proposal', kwargs=disapprove_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(200, response.status_code) self.assertEquals(False, self.proposal.is_approved) def test_disapprove_proposal_with_the_jury_user(self): self.event.jury.users.add(User.objects.get(username='******')) self.client.logout() self.client.login(username='******', password='******') self.proposal.is_approved = True self.proposal.save() disapprove_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug } response = self.client.post( reverse('disapprove_proposal', kwargs=disapprove_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(200, response.status_code) self.assertIn('message', json.loads(response.content)) self.assertEquals(False, self.proposal.is_approved) def test_disapprove_proposal_with_the_jury_user_by_get(self): self.event.jury.users.add(User.objects.get(username='******')) self.client.logout() self.client.login(username='******', password='******') self.proposal.is_approved = True self.proposal.save() disapprove_proposal_data = { 'event_slug': self.proposal.event.slug, 'slug': self.proposal.slug } response = self.client.get( reverse('disapprove_proposal', kwargs=disapprove_proposal_data), follow=True ) self.proposal = Proposal.objects.first() self.assertEquals(200, response.status_code) self.assertEquals(False, self.proposal.is_approved) def test_send_welcome_mail(self): User = namedtuple('User', 'email') fake_user = User('*****@*****.**') send_welcome_mail(None, fake_user) self.assertEqual(1, len(mail.outbox)) email = mail.outbox[0] self.assertTrue('Welcome', email.subject) self.assertIn(fake_user.email, email.recipients()) self.assertIn(settings.NO_REPLY_EMAIL, email.from_email) def test_send_proposal_deleted_mail(self): user = User.objects.get(username='******') self.proposal.event.jury.users.add(user) send_proposal_deleted_mail(Proposal, self.proposal) self.assertEqual(1, len(mail.outbox)) email = mail.outbox[0] self.assertEqual('Proposal from RuPy just got deleted', email.subject) self.assertIn('*****@*****.**', email.recipients()) self.assertIn('*****@*****.**', email.recipients()) self.assertIn('Python For Zombies', email.body) self.assertIn(settings.NO_REPLY_EMAIL, email.from_email) def test_my_proposals_menu_for_authenticated_users(self): response = self.client.get(reverse('list_events')) self.assertContains(response, 'My Proposals') def test_my_proposals_menu_for_non_authenticated_users(self): self.client.logout() response = self.client.get(reverse('list_events')) self.assertNotContains(response, 'My Proposals') def test_users_should_see_their_proposals(self): user = User.objects.get(username='******') self.proposal.author = user self.proposal.save() response = self.client.get(reverse('my_proposals')) self.assertQuerysetEqual(response.context['object_list'], ['<Proposal: Python For Zombies>'])
class TestViews(EleprofileTestBase): def setUp(self): self.client = Client() def _test_ACL(self, url, response_url=''): # As Anonymoususer: aspected 302 redirect con login response = self.client.get(url) self.assertEqual(response.status_code, 302) self.assertEqual(response.url, response_url) # As Viewer1 self.assertTrue( self.client.login(username=self.test_viewer1.username, password=self.test_viewer1.username)) response = self.client.get(url) self.assertEqual(response.status_code, 403) self.client.logout() def test_eleproproject_list(self): """ Testing ProjectView """ url = reverse('eleprofile-project-list') self._test_ACL(url, response_url='/en/login/?next=/en/eleprofile/projects/') # as Admin01 self.assertTrue( self.client.login(username=self.test_admin1.username, password=self.test_admin1.username)) response = self.client.get(url) self.assertEqual(response.status_code, 200) self.client.logout() # FIXME: add possible html tests parsing. def test_eleproproject_create(self): """ Testing ProjectCreateView """ url = reverse('eleprofile-project-add') self._test_ACL( url, response_url='/en/login/?next=/en/eleprofile/projects/add/') # as Admin01 self.assertTrue( self.client.login(username=self.test_admin1.username, password=self.test_admin1.username)) data = { 'project': self.project.instance.pk, 'note': "<strong>test</strong> note" } response = self.client.post(url, data) self.assertEqual(response.status_code, 302) self.assertEqual(response.url, '/en/eleprofile/projects/') eleproprjs = EleProProject.objects.all() self.assertEqual(len(eleproprjs), 1) self.assertEqual(eleproprjs[0].project_id, self.project.instance.pk) self.assertEqual(eleproprjs[0].note, "<strong>test</strong> note") self.client.logout() def test_eleproproject_update(self): """ Testing ProjectUpdateView """ # Create a eleproproject to update epp = EleProProject(project=self.project.instance, note="test note") epp.save() url = reverse('eleprofile-project-update', args=[epp.pk]) self._test_ACL( url, response_url= f'/en/login/?next=/en/eleprofile/projects/update/{epp.pk}/') # as Admin01 self.assertTrue( self.client.login(username=self.test_admin1.username, password=self.test_admin1.username)) data = {'project': epp.project_id, 'note': "test note updated"} response = self.client.post(url, data) self.assertEqual(response.status_code, 302) self.assertEqual(response.url, '/en/eleprofile/projects/') eleproprjs = EleProProject.objects.all() self.assertEqual(len(eleproprjs), 1) self.assertEqual(eleproprjs[0].project_id, self.project.instance.pk) self.assertEqual(eleproprjs[0].note, "test note updated") self.client.logout() def test_eleproproject_delete(self): """ Testing ProjectDeleteView """ # Create a eleproproject to update epp = EleProProject(project=self.project.instance, note="test note to delete") epp.save() url = reverse('eleprofile-project-delete', args=[epp.pk]) self._test_ACL( url, response_url= f'/en/login/?next=/en/eleprofile/projects/delete/{epp.pk}/') # as Admin01 self.assertTrue( self.client.login(username=self.test_admin1.username, password=self.test_admin1.username)) response = self.client.post(url) self.assertEqual(response.status_code, 200) eleproprjs = EleProProject.objects.all() self.assertEqual(len(eleproprjs), 0) self.client.logout() def test_dtmlayer_list(self): """ Testing DTMListView """ epp = EleProProject(project=self.project.instance, note="test for dtm layer and path layers") epp.save() url = reverse('eleprofile-dtmlayer-list', args=[epp.pk]) self._test_ACL( url, response_url= f'/en/login/?next=/en/eleprofile/projects/dtm/{epp.pk}/') # as Admin01 self.assertTrue( self.client.login(username=self.test_admin1.username, password=self.test_admin1.username)) response = self.client.get(url) self.assertEqual(response.status_code, 200) # parsing response content soup = BeautifulSoup(response.content, 'lxml') # check for empty table # only table th self.assertEqual(len(soup.find_all('tr')), 1) self.assertEqual(soup.find_all('tr')[0].th.text, 'Actions') self.client.logout() def test_dtmlayer_create(self): """ Testing DTMCreateView """ epp = EleProProject(project=self.project.instance, note="test for dtm layer and path layers") epp.save() url = reverse('eleprofile-dtmlayer-add', args=[epp.pk]) self._test_ACL( url, response_url= f'/en/login/?next=/en/eleprofile/projects/dtm/{epp.pk}/add/') # as Admin01 self.assertTrue( self.client.login(username=self.test_admin1.username, password=self.test_admin1.username)) dtm_layer = Layer.objects.get(name='dtm_3857') line_layer = Layer.objects.get(name='paths') data = { 'elepro_project': epp.pk, 'dtm_layer': dtm_layer.pk, 'dtm_delta': 10, 'layers': [line_layer.pk], 'note': "<strong>test</strong> note for dtm layers" } response = self.client.post(url, data) self.assertEqual(response.status_code, 302) self.assertEqual(response.url, f'/en/eleprofile/projects/dtm/{epp.pk}/') eleprodtm = EleProDTM.objects.all() self.assertEqual(len(eleprodtm), 1) self.assertEqual(eleprodtm[0].dtm_layer, dtm_layer) self.assertEqual(eleprodtm[0].note, "<strong>test</strong> note for dtm layers") # check list url = reverse('eleprofile-dtmlayer-list', args=[epp.pk]) response = self.client.get(url) self.assertEqual(response.status_code, 200) # parsing response content soup = BeautifulSoup(response.content, 'lxml') # check for empty table # only table th self.assertEqual(len(soup.find_all('tr')), 2) self.client.logout() def test_dtmlayer_update(self): """ Testing DTMUpdateView """ # Create a eleproproject epp = EleProProject(project=self.project.instance, note="test note") epp.save() # Create a DTM layer dtm_layer = Layer.objects.get(name='dtm_3857') line_layer = Layer.objects.get(name='paths') epdtm = EleProDTM(elepro_project=epp, dtm_layer=dtm_layer, note='note dtm layer for update') epdtm.save() epdtm.layers.add(line_layer) url = reverse('eleprofile-dtmlayer-update', args=[epp.pk, epdtm.pk]) self._test_ACL( url, response_url= f'/en/login/?next=/en/eleprofile/projects/dtm/{epp.pk}/update/{epdtm.pk}/' ) # as Admin01 self.assertTrue( self.client.login(username=self.test_admin1.username, password=self.test_admin1.username)) data = { 'elepro_project': epp.pk, 'dtm_layer': dtm_layer.pk, 'dtm_delta': 12, 'layers': [line_layer.pk], 'note': "test note updated" } response = self.client.post(url, data) self.assertEqual(response.status_code, 302) self.assertEqual(response.url, f'/en/eleprofile/projects/dtm/{epp.pk}/') eleprodtm = EleProDTM.objects.all() self.assertEqual(len(eleprodtm), 1) self.assertEqual(eleprodtm[0].elepro_project, epp) self.assertEqual(eleprodtm[0].dtm_delta, 12) self.assertEqual(eleprodtm[0].note, "test note updated") self.client.logout() def test_dtmlayer_delete(self): """ Testing DTMDeleteView """ # Create a eleproproject epp = EleProProject(project=self.project.instance, note="test note") epp.save() # Create a DTM layer dtm_layer = Layer.objects.get(name='dtm_3857') line_layer = Layer.objects.get(name='paths') epdtm = EleProDTM(elepro_project=epp, dtm_layer=dtm_layer, note='note dtm layer for update') epdtm.save() epdtm.layers.add(line_layer) url = reverse('eleprofile-dtmlayer-delete', args=[epp.pk, epdtm.pk]) self._test_ACL( url, response_url= f'/en/login/?next=/en/eleprofile/projects/dtm/{epp.pk}/delete/{epdtm.pk}/' ) # as Admin01 self.assertTrue( self.client.login(username=self.test_admin1.username, password=self.test_admin1.username)) eleprodtm = EleProDTM.objects.all() self.assertEqual(len(eleprodtm), 1) response = self.client.post(url) self.assertEqual(response.status_code, 200) eleprodtm = EleProDTM.objects.all() self.assertEqual(len(eleprodtm), 0) self.client.logout()
def test_user_logout(self): client = Client() client.logout()
class change_password_view_Test(TestCase): def setUp(self): self.client = Client() self.user = User.objects.create(email="*****@*****.**") self.user.set_password("abc123") self.user.save() def test_change_pwd_get(self): self.client.login(email="*****@*****.**", password="******") url = "/admin/change_password/" response = self.client.get(url) self.assertEqual(response.status_code, 200) def test_change_pwd_form_valid(self): user_login = self.client.login(email="*****@*****.**", password="******") url = "/admin/change_password/" data = { 'old_password': "******", 'new_password': "******", 're_password': "******" } response = self.client.post(url, data) self.assertEqual(response.status_code, 200) self.client.logout() user_login = self.client.login(email="*****@*****.**", password="******") self.assertTrue(user_login) def test_change_pwd_form_invalid(self): self.client.login(email="*****@*****.**", password="******") url = "/admin/change_password/" data = { 'old_password': "******", 'new_password': "", 're_password': "" } response = self.client.post(url, data) self.assertEqual(response.status_code, 200) def test_change_re_pwd(self): self.client.login(email="*****@*****.**", password="******") url = "/admin/change_password/" data = { 'old_password': "******", 'new_password': "******", 're_password': "******" } response = self.client.post(url, data) self.assertEqual(response.status_code, 200) def test_change_old_pwd(self): self.client.login(email="*****@*****.**", password="******") url = "/admin/change_password/" data = { 'old_password': "******", 'new_password': "******", 're_password': "******" } response = self.client.post(url, data) self.assertEqual(response.status_code, 200)
class ViewsTest(TestCase): """ Class with testclient to test views. Some functions to setup data in the database. """ def setUp(self): """ Setup test data, like users and groups. """ # whether to produce output, please override this on app level if debug is required. self.debug = False # to test that each page is at least tested once, check if all urls of the app are tested. urlpatterns = import_module(self.app + '.urls', 'urlpatterns').urlpatterns self.allurls = [x.name for x in urlpatterns] # the client used for testing if TEST_HTML_VALID: self.client = ValidatingClient() else: self.client = Client() # info string to show debug info in case of test assertion failure self.info = {} # The timeslot used for testing proposal of current timeslot self.ts = TimeSlot(Begin=datetime.now(), End=datetime.now() + timedelta(days=3), Name='thisyear') self.ts.save() # The timephase used for testing. The Description is changed every test. self.tp = TimePhase(Begin=datetime.now(), End=datetime.now() + timedelta(days=3), TimeSlot=self.ts, Description=1) self.tp.save() # The timeslot used for testing proposal of next timeslot self.nts = TimeSlot(Begin=datetime.now() + timedelta(days=5), End=datetime.now() + timedelta(days=8), Name='nextyear') self.nts.save() # The timeslot used for testing proposal of previous timeslot self.pts = TimeSlot(Begin=datetime.now() - timedelta(days=5), End=datetime.now() - timedelta(days=3), Name='prevyear') self.pts.save() # Create capacity groups models groups = (("EES", "Electrical Energy Systems"), ("ECO", "Electro-Optical Communications"), ("EPE", "Electromechanics and Power Electronics"), ("ES", "Electronic Systems"), ("IC", "Integrated Circuits"), ("CS", "Control Systems"), ("SPS", "Signal Processing Systems"), ("PHI", "Photonic Integration"), ("EM", "Electromagnetics")) for group in groups: self.c, created = CapacityGroup.objects.get_or_create( ShortName=group[0], FullName=group[1]) assert created # Create groups and users self.create_groups() self.create_users() # Track for automotive, with trackhead t-h. Automotive track must exist because it is special. (distributions) th = User.objects.get(username='******') self.track = Track(Name='Automotive', ShortName='AU', Head=th) self.track.save() grt = User.objects.get(username='******') grr = User.objects.get(username='******') # only read/write administration is tested. Not readonly. g = GroupAdministratorThrough(User=grt, Super=True, Group=CapacityGroup.objects.all()[0]) g.save() g2 = GroupAdministratorThrough(User=grr, Super=True, Group=CapacityGroup.objects.all()[1]) g2.save() ## setup matrix with all possible rights # expected results: # r=random, t=this(for this proposal) # s=student, p=private-student, r=responsible, a=assistant, u=assistant_not_verified t=trackhead # ta = assessor of presentation, 4=groupadministration, 5=studyadvisor, 6=profskill # matrix with different types of permissions, set for each user of the array self.usernames # permissions by user. The order is the order of self.usernames. User 'god' is disabled (not tested). # usernames: r-1 t-1 r-h t-h r-2 t-2 t-u r-3 r-s t-p r-4 t-4 r-5 r-6 ra-1 ta-1 sup, ano self.p_forbidden = [ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 302 ] # no one self.p_superuser = [ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 200, 302 ] # no one self.p_all = [ 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 302 ] # everyone self.p_anonymous = [ 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200 ] # everyone self.p_redirect = [ 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302 ] # everyone self.p_staff = [ 200, 200, 200, 200, 200, 200, 200, 200, 403, 403, 200, 200, 200, 200, 200, 200, 200, 302 ] # all staff, general self.p_staff_veri = [ 200, 200, 200, 200, 200, 200, 403, 200, 403, 403, 200, 200, 200, 200, 200, 200, 200, 302 ] # all staff, without unverified self.p_staff122u35 = [ 200, 200, 200, 200, 200, 200, 200, 200, 403, 403, 403, 403, 200, 403, 200, 200, 200, 302 ] # all staff, for chooseedit list self.p_staff_prop = [ 200, 200, 200, 200, 200, 200, 200, 200, 403, 403, 200, 200, 403, 403, 200, 200, 200, 302 ] # all staff, to create proposals self.p_staff_prop_no4 = [ 200, 200, 200, 200, 200, 200, 200, 200, 403, 403, 403, 403, 403, 403, 200, 200, 200, 302 ] # all staff to create but no type4 self.p_staff_prop_nou = [ 200, 200, 200, 200, 200, 200, 403, 200, 403, 403, 200, 200, 403, 403, 200, 200, 200, 302 ] # all staff, to create proposals, no unverified self.p_staff_stud = [ 200, 200, 200, 200, 200, 200, 403, 200, 403, 403, 403, 403, 403, 200, 200, 200, 200, 302 ] # all staff that can see students (1,2,3,6) self.p_all_this = [ 403, 200, 403, 200, 403, 200, 200, 200, 403, 403, 403, 200, 403, 403, 403, 403, 200, 302 ] # staff of this proposal self.p_all_this_pres = [ 403, 200, 403, 200, 403, 200, 200, 200, 403, 403, 403, 200, 403, 403, 403, 200, 200, 302 ] # staff of this proposal including ta-1 self.p_all_this_dist = [ 403, 200, 403, 200, 403, 200, 403, 200, 200, 403, 403, 403, 403, 200, 403, 403, 200, 302 ] # staff of this proposal, as distributed to r-s (not t-p!). Also type6. For prv (no assessors) self.p_no_assistant = [ 403, 200, 403, 200, 403, 403, 403, 200, 403, 403, 403, 200, 403, 403, 403, 403, 200, 302 ] # staff of this proposal except assistants. For up/downgrading and edit proposal. self.p_staff_prv_results = [ 403, 200, 403, 200, 403, 200, 403, 200, 403, 403, 403, 403, 403, 403, 403, 403, 200, 302 ] # staff of this proposal except assistants including assessors. For results staff grading form, without assessor. self.p_staff_results = [ 403, 200, 403, 200, 403, 403, 403, 200, 403, 403, 403, 403, 403, 403, 403, 200, 200, 302 ] # staff of this proposal except assistants including assessors. For results staff grading form. self.p_all_this_view = [ 403, 200, 403, 200, 403, 200, 200, 200, 403, 403, 403, 200, 403, 403, 403, 403, 200, 302 ] # staff of this proposal including view only users (type4) self.p_private = [ 403, 200, 403, 200, 403, 200, 200, 200, 403, 200, 403, 200, 403, 403, 403, 403, 200, 302 ] # private proposal view status 4 self.p_private_pres = [ 403, 200, 403, 200, 403, 200, 200, 200, 403, 200, 403, 200, 403, 403, 403, 200, 200, 302 ] # private proposal view status 4, in phase 7 or if presentation is public. self.p_trackhead = [ 403, 403, 403, 200, 403, 403, 403, 200, 403, 403, 403, 200, 403, 403, 403, 403, 200, 302 ] # trackhead of proposal and support self.p_grade_final = [ 403, 403, 403, 200, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 200, 200, 302 ] # Trackhead and assessor can finalize grades. self.p_grade_staff = [ 403, 200, 403, 200, 403, 403, 403, 200, 403, 403, 403, 403, 403, 403, 403, 200, 200, 302 ] # staff of this proposal except assistants, for grading self.p_track = [ 403, 403, 200, 200, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 302 ] # any trackhead self.p_pending = [ 200, 200, 200, 200, 200, 200, 200, 403, 403, 403, 200, 200, 403, 403, 200, 200, 200, 302 ] # staff with pending proposals self.p_support = [ 403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 403, 403, 403, 403, 403, 403, 200, 302 ] # type3 support self.p_support_prv = [ 403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 403, 403, 403, 200, 403, 403, 200, 302 ] # 3+6 self.p_cgadmin = [ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 200, 200, 403, 403, 403, 403, 200, 302 ] # type4 (not superuser) # self.p_study = [403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 403, 200, 302] # type5 self.p_prv = [ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 200, 302 ] # 6 self.p_student = [ 403, 403, 403, 403, 403, 403, 403, 403, 200, 200, 403, 403, 403, 403, 403, 403, 403, 302 ] # any student self.p_studentnotpriv = [ 403, 403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 403, 403, 403, 403, 403, 403, 302 ] # student without private proposal self.p_download_share = [ 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 403 ] # used to test filesdownload (with sharelink proposals) self.p_404 = [ 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 302 ] # used to test filesdownload def create_groups(self): """ Create all groups for the system. :param self: :return: """ # setup all groups self.group_names = [ 'type1staff', # project responsible 'type2staff', # project assistant 'type2staffunverified', # unverified assistant 'type3staff', # support staff 'type4staff', # Capacity group administration 'type5staff', # Study advisor 'type6staff', # Prof skill administration ] for g in self.group_names: group, created = Group.objects.get_or_create(name=g) assert created # make group object accessable as a class variable. < self.type1staff > etc. setattr(self, g, group) def create_users(self): """ Takes self.usernames and creates users based on this. The last character of the username determnines the group WARNING: This only generates users and assign groups. It does not assign roles (like groupadministration and trackhead models). """ # create testusers using the naming-patern: [r t]-[s p 1 2 u 3 t ] # r=random (any person of the given type), t=this(for this project) # 1=type1, 2=type2, 3=type3, s=Student, u=Unverified-type2, h=track-Head, p=Private-student self.usernames = [ 'r-1', # responsible staff 't-1', # responsible staff 'r-h', # responsible staff, trackhead 't-h', # responsible staff, trackhead 'r-2', # assistant 't-2', # assistant 't-u', # unverified assistant 'r-3', # support staff 'r-s', # student without private proposal 't-p', # student with private proposal 'r-4', # Capacity group administration of other group than tested proposal 't-4', # Capacity group administration of group of tested proposal 'r-5', # Study advisor 'r-6', # Prof skill administration 'ra-1', # type1 and assessor of other project 'ta-1', # type1 and assessor of project 'sup', # god user (superuser) 'ano', # anonymous user ] # Create the users and assign groups/roles. self.users = {} for n in self.usernames: if n != 'ano': u = User(username=n) u.email = n + '@' + settings.STAFF_EMAIL_DOMAINS[0] u.save() x = n.split('-')[-1] if x == '1': u.groups.add(self.type1staff) elif x == 'h': # trackhead u.groups.add(self.type1staff) elif x == '2': u.groups.add(self.type2staff) elif x == 'u': u.groups.add(self.type2staffunverified) elif x == '3': u.groups.add(self.type3staff) elif x == '4': u.groups.add(self.type4staff) elif x == '5': u.groups.add(self.type5staff) elif x == '6': u.groups.add(self.type6staff) elif n == 'sup': u.groups.add(self.type3staff) u.is_superuser = True u.is_staff = True else: # student u.email = n + '@' + settings.STUDENT_EMAIL_DOMAINS[0] u.save() self.users[n] = u m = UserMeta( User=u, EnrolledBEP=True, ) m.save() m.TimeSlot.add(self.ts) m.save() ua = UserAcceptedTerms(User=u) ua.save() def links_in_view_test(self, sourceurl, skip=[]): """ Find all links in a response and check if they return status 200. :param sourceurl: the page which is parsed to test the links on the page. :param skip: urls to not test :return: """ for user in self.users.values(): if (user.username == 't-u' or user.username == 'r-u') and \ self.tp.Description > 3: # ignore unverfied assistants in later timephases continue if (user.username == 't-p' or user.username == 't-s') and \ self.tp.Description < 3: # ignore students in first timephases continue self.client.force_login(user) response = self.client.get(sourceurl) urls = re.findall( '/(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+/', str(response.content)) urls = [ x for x in urls if (">" not in x and "<" not in x and "//" not in x and "/static/" not in x and "/logout/" not in x and "tracking/live/" not in x and "tracking/viewnumber/" not in x and "js_error_hook" not in x and x not in skip) ] for link in urls: # select the url in href for all a tags(links) if link in skip: continue if self.debug: print('url: {}'.format(link)) self.info['user'] = user.username self.view_test_status(link, 200) self.client.logout() def loop_phase_code_user(self, phases, codes): """ Loop over the given phases and test with all codes :param phases: :param codes: list of views and expected status codes :return: """ assert isinstance(phases, list) or isinstance(phases, range) for phase in phases: if phase != get_timephase_number(): if phase == -1: self.tp.Begin = datetime.now() + timedelta(days=1) self.tp.save() self.info['phase'] = 'No Phase' else: self.tp.Begin = datetime.now() self.tp.Description = phase self.tp.save() self.info['phase'] = str(phase) if self.debug: print("Testing phase {}".format(phase)) self.loop_code_user(codes) def loop_code_user(self, codes): """ Test all views for all users :param codes: list of views and expected status codes :return: """ for page, status in codes: if self.debug: self.info['reverse'] = str(page) self.info['statuscodes'] = status view = self.app + ":" + page[0] if any(isinstance(i, list) for i in status): # we're dealing with proposals status tests here ProjectViewsTestGeneral.loop_user_status( self, view, status, page[1]) else: # normal test without proposals self.loop_user(view, status, page[1]) # remove the page from the list of urls of this app. if page[0] in self.allurls: self.allurls.remove(page[0]) def loop_user(self, view, status, kw=None): """ Loop over the provided pages with status code for each user and test these. :param view: name of the page, for reverse view :param status: array of http status that is expected for each user :param kw: keyword args for the given view. :return: """ for i, username in enumerate(self.usernames): self.info['user'] = username self.info['kw'] = kw if self.debug: self.info['user-index'] = i # log the user in if username != 'ano': u = User.objects.get(username=username) if self.debug: self.info['user-groups'] = u.groups.all() self.info['user-issuper'] = u.is_superuser self.client.force_login(u) self.view_test_status(reverse(view, kwargs=kw), status[i]) if username != 'ano': self.client.logout() def view_test_status(self, link, expected): """ Test a given view :param self: the instance for the testcase class, containing self.client, the testclient instance. :param link: a link to a view to test :param expected: the expected response code :return: """ try: response = self.client.get(link) response_code = response.status_code if response_code == 403 or expected == 403: try: exception = list(response.context[0])[0]["exception"] except: try: exception = list(response.context[0])[0]["Message"] except: # exception = response.context # this is a large amount of information exception = 'Reason not found in context!' self.info['exception'] = exception else: if response_code == 404: for d in response.context.dicts: try: self.info['exception'] = d['Message'] break except: continue else: self.info['exception'] = "no 403" except Exception as e: response_code = 500 print("Error: {}".format(e)) self.info['exception'] = '500' traceback.print_exc(file=sys.stdout) self.assertEqual( response_code, expected, msg='Expected status code {} but got {} for {} info: {}.'.format( expected, response_code, link, self.info))
class EntryAdminViewTest(TestCase): @classmethod def setUpTestData(cls): cls.entry1 = Registration.objects.create( first_name="John", last_name="Doe", email="*****@*****.**", programme="computingscience", student_number="s1234567", starting_year=2014, address_street="Heyendaalseweg 135", address_street2="", address_postal_code="6525AJ", address_city="Nijmegen", address_country="NL", phone_number="06123456789", birthday=timezone.now().replace(year=1990, day=1), length=Entry.MEMBERSHIP_YEAR, membership_type=Membership.MEMBER, status=Entry.STATUS_CONFIRM, ) cls.user = get_user_model().objects.create_user(username="******") cls.entry2 = Renewal.objects.create( length=Entry.MEMBERSHIP_YEAR, membership_type=Membership.MEMBER, status=Entry.STATUS_CONFIRM, member=cls.user, ) def setUp(self): self.rf = RequestFactory() self.client = Client() self.client.force_login(self.user) self.view = views.EntryAdminView() def _give_user_permissions(self): content_type = ContentType.objects.get_for_model(Entry) permissions = Permission.objects.filter( content_type__app_label=content_type.app_label, ) for p in permissions: self.user.user_permissions.add(p) self.user.is_staff = True self.user.save() self.client.logout() self.client.force_login(self.user) def test_permissions(self): url = "/registration/admin/process/{}/".format(self.entry1.pk) response = self.client.post(url) self.assertRedirects(response, f"/admin/login/?next={url}") self._give_user_permissions() url = "/registration/admin/process/{}/".format(self.entry1.pk) response = self.client.post(url) self.assertRedirects( response, f"/admin/registrations/registration/{self.entry1.pk}/change/") @mock.patch("registrations.services.check_unique_user") @mock.patch("registrations.services.accept_entries") @mock.patch("registrations.services.reject_entries") def test_post_accept(self, reject_entries, accept_entries, check_unique_user): self.view.action = "accept" for reg_type, entry in { "registration": self.entry1, "renewal": self.entry2, }.items(): entry_qs = Entry.objects.filter(pk=entry.pk) check_unique_user.reset_mock() check_unique_user.return_value = True reject_entries.reset_mock() reject_entries.return_value = 1 accept_entries.reset_mock() accept_entries.return_value = 1 with mock.patch( "registrations.models.Entry.objects.filter") as qs_mock: qs_mock.return_value = entry_qs qs_mock.get = Mock(return_value=entry_qs.get()) request = self.rf.post( f"/registration/admin/process/{entry.pk}/", { "action": "accept", }) request.user = _get_mock_user() request.member = request.user request._messages = Mock() response = self.view.post(request, pk=entry.pk) self.assertEqual(response.status_code, 302) self.assertEqual( response.url, f"/admin/registrations/{reg_type}/{entry.pk}/change/", ) accept_entries.assert_called_once_with(1, entry_qs) self.assertFalse(reject_entries.called) request._messages.add.assert_called_once_with( messages.SUCCESS, _("Successfully accepted %s.") % model_ngettext(entry_qs.all()[0], 1), "", ) accept_entries.return_value = 0 self.view.post(request, pk=entry.pk) request._messages.add.assert_any_call( messages.ERROR, _("Could not accept %s.") % model_ngettext(entry_qs.all()[0], 1), "", ) accept_entries.return_value = 1 check_unique_user.return_value = False self.view.post(request, pk=entry.pk) request._messages.add.assert_any_call( messages.ERROR, _("Could not accept %s. Username is not unique.") % model_ngettext(entry_qs.all()[0], 1), "", ) @mock.patch("registrations.services.accept_entries") @mock.patch("registrations.services.reject_entries") def test_post_reject(self, reject_entries, accept_entries): self.view.action = "reject" for reg_type, entry in { "registration": self.entry1, "renewal": self.entry2, }.items(): accept_entries.reset_mock() accept_entries.return_value = 1 reject_entries.reset_mock() reject_entries.return_value = 1 entry_qs = Entry.objects.filter(pk=entry.pk) with mock.patch( "registrations.models.Entry.objects.filter") as qs_mock: qs_mock.return_value = entry_qs qs_mock.get = Mock(return_value=entry_qs.get()) request = self.rf.post( f"/registration/admin/process/{entry.pk}/", { "action": "reject", }) request.user = _get_mock_user() request.member = request.user request._messages = Mock() response = self.view.post(request, pk=entry.pk) self.assertEqual(response.status_code, 302) self.assertEqual( response.url, f"/admin/registrations/{reg_type}/{entry.pk}/change/", ) reject_entries.assert_called_once_with(1, entry_qs) self.assertFalse(accept_entries.called) request._messages.add.assert_called_once_with( messages.SUCCESS, _("Successfully rejected %s.") % model_ngettext(entry_qs.all()[0], 1), "", ) reject_entries.return_value = 0 self.view.post(request, pk=entry.pk) request._messages.add.assert_any_call( messages.ERROR, _("Could not reject %s.") % model_ngettext(entry_qs.all()[0], 1), "", ) @mock.patch("registrations.emails.send_registration_email_confirmation") def test_post_resend(self, send_email): self.view.action = "resend" for reg_type, entry in { "registration": self.entry1, "renewal": self.entry2, }.items(): entry_qs = Entry.objects.filter(pk=entry.pk) send_email.reset_mock() send_email.return_value = None with mock.patch( "registrations.models.Entry.objects.filter") as qs_mock: qs_mock.return_value = entry_qs qs_mock.get = Mock(return_value=entry_qs.get()) request = self.rf.post( f"/registration/admin/process/{entry.pk}/", { "action": "resend", }) request.user = _get_mock_user() request.member = request.user request._messages = Mock() response = self.view.post(request, pk=entry.pk) self.assertEqual(response.status_code, 302) self.assertEqual( response.url, f"/admin/registrations/{reg_type}/{entry.pk}/change/", ) if reg_type == "registration": send_email.assert_called_once_with(entry) elif reg_type == "renewal": send_email.assert_not_called() @mock.patch("registrations.services.revert_entry") def test_post_revert(self, revert): self.view.action = "revert" for reg_type, entry in { "registration": self.entry1, "renewal": self.entry2, }.items(): entry_qs = Entry.objects.filter(pk=entry.pk) revert.reset_mock() revert.return_value = None with mock.patch( "registrations.models.Entry.objects.filter") as qs_mock: qs_mock.return_value = entry_qs qs_mock.get = Mock(return_value=entry_qs.get()) request = self.rf.post( f"/registration/admin/process/{entry.pk}/", { "action": "revert", }) request.user = _get_mock_user() request.member = request.user request._messages = Mock() response = self.view.post(request, pk=entry.pk) self.assertEqual(response.status_code, 302) self.assertEqual( response.url, f"/admin/registrations/{reg_type}/{entry.pk}/change/", ) revert.assert_called_once_with(1, entry.entry_ptr) @mock.patch("registrations.models.Entry.objects.filter") def test_post_not_exists(self, qs_mock): qs_mock.return_value = MagicMock(get=Mock( side_effect=Entry.DoesNotExist, return_value=4, )) request = self.rf.post("/registration/admin/process/1234/", {"action": "accept"}) request.user = _get_mock_user() request.member = request.user request._messages = Mock() response = self.view.post(request, pk=4) self.assertEqual(response.status_code, 302) self.assertEqual(response.url, reverse("admin:index")) @mock.patch("registrations.services.accept_entries") @mock.patch("registrations.services.reject_entries") def test_post_no_action(self, reject_entries, accept_entries): self.view.action = None for reg_type, entry in { "registration": self.entry1, "renewal": self.entry2, }.items(): entry_qs = Entry.objects.filter(pk=entry.pk) accept_entries.reset_mock() accept_entries.return_value = 1 reject_entries.reset_mock() reject_entries.return_value = 1 with mock.patch( "registrations.models.Entry.objects.filter") as qs_mock: qs_mock.return_value = entry_qs qs_mock.get = Mock(return_value=entry_qs.get()) request = self.rf.post( f"/registration/admin/process/{entry.pk}/", ) request.user = _get_mock_user() request.member = request.user request._messages = Mock() response = self.view.post(request, pk=entry.pk) self.assertFalse(reject_entries.called) self.assertFalse(accept_entries.called) self.assertEqual(response.status_code, 302) self.assertEqual( response.url, f"/admin/registrations/{reg_type}/{entry.pk}/change/", )
def test(self): # Update ambulance a1 a = self.a1 user = self.u1 status = AmbulanceStatus.AH.name serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id), data={ 'status': status, }, partial=True) serializer.is_valid() serializer.save(updated_by=user) timestamp = timezone.now() location = {'latitude': -2., 'longitude': 7.} serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id), data={ 'location': location, 'timestamp': timestamp }, partial=True) serializer.is_valid() serializer.save(updated_by=user) status = AmbulanceStatus.OS.name serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id), data={ 'status': status, }, partial=True) serializer.is_valid() serializer.save(updated_by=user) # This update does not go to AmbulanceUpdate! serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id), data={ 'identifier': 'someid', }, partial=True) serializer.is_valid() serializer.save(updated_by=user) # test AmbulanceUpdateSerializer queryset = AmbulanceUpdate.objects.filter(ambulance=a) answer1 = [] for u in queryset: serializer = AmbulanceUpdateSerializer(u) result = { 'id': u.id, 'ambulance_id': u.ambulance.id, 'ambulance_identifier': u.ambulance.identifier, 'comment': u.comment, 'capability': u.capability, 'status': u.status, 'orientation': u.orientation, 'location': point2str(u.location), 'timestamp': date2iso(u.timestamp), 'updated_by_username': u.updated_by.username, 'updated_on': date2iso(u.updated_on) } answer1.append(serializer.data) self.assertDictEqual(serializer.data, result) # Update ambulance a2 a = self.a3 user = self.u3 status = AmbulanceStatus.AH.name serializer = AmbulanceSerializer(a, data={ 'status': status, }, partial=True) serializer.is_valid() serializer.save(updated_by=user) timestamp = timezone.now() location = {'latitude': -2., 'longitude': 7.} serializer = AmbulanceSerializer(a, data={ 'location': location, 'timestamp': timestamp }, partial=True) serializer.is_valid() serializer.save(updated_by=user) status = AmbulanceStatus.OS.name serializer = AmbulanceSerializer(a, data={ 'status': status, }, partial=True) serializer.is_valid() serializer.save(updated_by=user) # test AmbulanceUpdateSerializer queryset = AmbulanceUpdate.objects.filter(ambulance=a) answer3 = [] for u in queryset: serializer = AmbulanceUpdateSerializer(u) result = { 'id': u.id, 'ambulance_id': u.ambulance.id, 'ambulance_identifier': a.identifier, 'comment': u.comment, 'capability': u.capability, 'status': u.status, 'orientation': u.orientation, 'location': point2str(u.location), 'timestamp': date2iso(u.timestamp), 'updated_by_username': u.updated_by.username, 'updated_on': date2iso(u.updated_on) } answer3.append(serializer.data) self.assertDictEqual(serializer.data, result) # Test api # instantiate client client = Client() # login as admin client.login(username=settings.MQTT['USERNAME'], password=settings.MQTT['PASSWORD']) # retrieve ambulances updates response = client.get('/en/api/ambulance/{}/updates/'.format( self.a1.id), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertCountEqual(result, answer1) self.assertEqual(len(result), 4) # retrieve ambulances updates response = client.get('/en/api/ambulance/{}/updates/'.format( self.a3.id), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertCountEqual(result, answer3) self.assertEqual(len(result), 4) # logout client.logout() # login as testuser1 client.login(username='******', password='******') # retrieve ambulances response = client.get('/en/api/ambulance/{}/updates/'.format( self.a1.id), follow=True) self.assertEqual(response.status_code, 404) # retrieve ambulances response = client.get('/en/api/ambulance/{}/updates/'.format( self.a3.id), follow=True) self.assertEqual(response.status_code, 404) # logout client.logout() # login as testuser2 client.login(username='******', password='******') # retrieve ambulances response = client.get('/en/api/ambulance/{}/updates/'.format( self.a1.id), follow=True) self.assertEqual(response.status_code, 404) # retrieve ambulances updates response = client.get('/en/api/ambulance/{}/updates/'.format( self.a3.id), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertCountEqual(result, answer3) self.assertEqual(len(result), 4) # logout client.logout()
class ReferenceCreateViewTest(TestCase): """ Test for the ReferenceCreateView """ fixtures = ["members.json"] @classmethod def setUpTestData(cls): cls.login_user = Member.objects.filter(last_name="Wiggers").first() cls.registration = Registration.objects.create( first_name="John", last_name="Doe", email="*****@*****.**", programme="computingscience", student_number="s1234567", starting_year=2014, address_street="Heyendaalseweg 135", address_street2="", address_postal_code="6525AJ", address_city="Nijmegen", address_country="NL", phone_number="06123456789", birthday=timezone.now().replace(year=1990, day=1), length=Entry.MEMBERSHIP_YEAR, contribution=7.50, membership_type=Membership.BENEFACTOR, status=Entry.STATUS_CONFIRM, ) cls.new_user = get_user_model().objects.create_user( username="******", first_name="Johnny", last_name="Test") cls.renewal = Renewal.objects.create( length=Entry.MEMBERSHIP_YEAR, contribution=7.50, membership_type=Membership.BENEFACTOR, status=Entry.STATUS_CONFIRM, member=cls.new_user, ) def setUp(self): self.rf = RequestFactory() self.view = views.ReferenceCreateView() self.client = Client() self.client.force_login(self.login_user) def test_not_logged_in(self): """ If there is no logged-in user they should redirect to the authentication page """ self.client.logout() response = self.client.get( reverse("registrations:reference", args=(self.registration.pk, )), follow=True, ) self.assertEqual(200, response.status_code) self.assertEqual( [( "/user/login/?next=" + reverse("registrations:reference", args=(self.registration.pk, )), 302, )], response.redirect_chain, ) def test_not_a_current_member(self): """ If the logged-in user is not a member they should not be able to visit this page """ self.client.logout() self.client.force_login(self.new_user) response = self.client.get( reverse("registrations:reference", args=(self.registration.pk, ))) self.assertEqual(403, response.status_code) def test_entry_does_not_exist(self): """ If the registration/renewal does not exist a 404 should be shown """ response = self.client.get( reverse( "registrations:reference", args=("00000000-0000-0000-0000-000000000000", ), )) self.assertEqual(404, response.status_code) def test_entry_no_references_required(self): """ If the registration/renewal does not require references a 404 should be shown """ self.registration.no_references = True self.registration.save() response = self.client.get( reverse("registrations:reference", args=(self.registration.pk, ))) self.assertEqual(404, response.status_code) def test_entry_no_benefactor(self): """ If the registration/renewal is not a the benefactor type a 404 should be shown """ self.registration.membership_type = Membership.MEMBER self.registration.save() response = self.client.get( reverse("registrations:reference", args=(self.registration.pk, ))) self.assertEqual(404, response.status_code) def test_entry_shows_info(self): """ If everything is alright the info and submission buttons should be shown """ with self.subTest("Registration"): response = self.client.get( reverse("registrations:reference", args=(self.registration.pk, ))) self.assertEqual(200, response.status_code) self.assertEqual("John Doe", response.context["name"]) self.assertEqual(False, response.context["success"]) self.assertContains( response, "<strong>John Doe</strong> wants to become a benefactor") with self.subTest("Renewal"): response = self.client.get( reverse("registrations:reference", args=(self.renewal.pk, ))) self.assertEqual(200, response.status_code) self.assertEqual("Johnny Test", response.context["name"]) self.assertEqual(False, response.context["success"]) self.assertContains( response, "<strong>Johnny Test</strong> wants to become a benefactor") def test_entry_saves_correctly(self): """ If a entry is saved it should redirect to the success page which should show the right content. And the Reference object should be saved. """ response = self.client.post( reverse("registrations:reference", args=(self.registration.pk, )), follow=True, ) self.assertEqual(200, response.status_code) self.assertEqual( [( reverse("registrations:reference-success", args=(self.registration.pk, )), 302, )], response.redirect_chain, ) self.assertEqual("John Doe", response.context["name"]) self.assertEqual(True, response.context["success"]) self.assertContains(response, "Your reference has been saved.") self.assertTrue( Reference.objects.filter(member=self.login_user, entry=self.registration).exists()) def test_entry_reference_exists(self): """ If there is already a reference for an entry then the page should show an error and not redirect. """ Reference.objects.create(member=self.login_user, entry=self.registration) response = self.client.post( reverse("registrations:reference", args=(self.registration.pk, )), follow=True, ) self.assertEqual(200, response.status_code) self.assertEqual([], response.redirect_chain) self.assertEqual( {"__all__": ["You've already given a reference for this person."]}, response.context["form"].errors, ) self.assertEqual(False, response.context["success"]) self.assertContains( response, "You've already given a reference for this person.")
def test_ambulance_patch_viewset(self): # instantiate client client = Client() # login as admin client.login(username=settings.MQTT['USERNAME'], password=settings.MQTT['PASSWORD']) # retrieve ambulance response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(self.a1).data self.assertDictEqual(result, answer) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/en/api/ambulance/{}/'.format(str( self.a1.id)), content_type='application/json', data=json.dumps({ 'status': status, }), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a1.id)).data self.assertDictEqual(result, answer) # retrieve new ambulance status response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertEqual(result['status'], status) # set status location timestamp = timezone.now() location = {'latitude': -2., 'longitude': 7.} response = client.patch('/en/api/ambulance/{}/'.format(str( self.a1.id)), content_type='application/json', data=json.dumps({ 'location': point2str(location), 'timestamp': date2iso(timestamp), }), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a1.id)).data if math.fabs(answer['orientation'] - result['orientation']) < 1e-4: answer['orientation'] = result['orientation'] self.assertDictEqual(result, answer) # retrieve new ambulance location response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id))) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertEqual(result['status'], status) self.assertEqual(result['location'], point2str(location)) self.assertEqual(result['timestamp'], date2iso(timestamp)) # set wrong attribute response = client.patch('/en/api/ambulance/{}/'.format(str( self.a1.id)), content_type='application/json', data=json.dumps({'status': 'will fail'}), follow=True) self.assertEqual(response.status_code, 400) # set wrong ambulance id response = client.patch('/en/api/ambulance/100/', data=json.dumps({'status': status}), follow=True) self.assertEqual(response.status_code, 404) # logout client.logout() # login as testuser2 client.login(username='******', password='******') # retrieve ambulance response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(self.a3).data self.assertDictEqual(result, answer) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/en/api/ambulance/{}/'.format(str( self.a3.id)), content_type='application/json', data=json.dumps({ 'status': status, }), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data self.assertDictEqual(result, answer) # retrieve new ambulance status response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertEqual(result['status'], status) # set location timestamp = timezone.now() location = {'latitude': -2., 'longitude': 7.} response = client.patch('/en/api/ambulance/{}/'.format(str( self.a3.id)), content_type='application/json', data=json.dumps({ 'location': point2str(location), 'timestamp': date2iso(timestamp), }), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data if math.fabs(answer['orientation'] - result['orientation']) < 1e-4: answer['orientation'] = result['orientation'] self.assertDictEqual(result, answer) # retrieve new ambulance location response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)), follow=True) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertEqual(result['status'], status) self.assertEqual(result['location'], point2str(location)) self.assertEqual(result['timestamp'], date2iso(timestamp)) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/en/api/ambulance/{}/'.format(str( self.a1.id)), content_type='application/json', data=json.dumps({ 'status': status, }), follow=True) self.assertEqual(response.status_code, 404) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/en/api/ambulance/{}/'.format(str( self.a2.id)), content_type='application/json', data=json.dumps({ 'status': status, }), follow=True) self.assertEqual(response.status_code, 404) # logout client.logout() # login as testuser1 client.login(username='******', password='******') # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/en/api/ambulance/{}/'.format(str( self.a1.id)), content_type='application/json', data=json.dumps({ 'status': status, }), follow=True) self.assertEqual(response.status_code, 404) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/en/api/ambulance/{}/'.format(str( self.a2.id)), content_type='application/json', data=json.dumps({ 'status': status, }), follow=True) self.assertEqual(response.status_code, 404) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/en/api/ambulance/{}/'.format(str( self.a3.id)), content_type='application/json', data=json.dumps({ 'status': status, }), follow=True) self.assertEqual(response.status_code, 404) # logout client.logout()
class TestViews(TestCase): """Testing Views with Client without launching server""" def setUp(self): self.client = Client() self.snake_family_name = Family.objects.create(name='Family_For_All') self.snake_specia_name = 'Snake_For_All' self.specia_1 = Specia.objects.create( name=self.snake_specia_name, family=self.snake_family_name, ) self.snake_name_1 = 'Varga' self.snake = Snake.objects.create( name=self.snake_name_1, specia=self.specia_1 ) def test_index(self): response = self.client.get('/') self.assertEqual(response.status_code, 200) # self.assertEqual(response.status_code, 201) encoding = 'utf-8' text = response.content.decode(encoding) searched = '<button type="submit" class="btn btn-primary">Save and send</button>' # check if buttons exist in the page self.assertTrue(searched in text) # print(response.context) self.assertTrue('object_list' in response.context.keys()) self.assertTrue('active_page' in response.context.keys()) self.assertEqual(response.context['active_page'], "1") # Что желательно проверить в views # 1. status code для разных пользователей # 2. Проверка создаваемых из форм объектов # 3. Контекст def test_permissions(self): # авторизация пользователя admin = User.objects.create_superuser('admin', '*****@*****.**', '12345678qwerty') staff = User.objects.create_user('staff', '*****@*****.**', '12345678qwerty', is_staff=True) user = User.objects.create_user('user', '*****@*****.**', '12345678qwerty', is_staff=False) # snake/<int:pk>/delete/ url = f'/snake/{self.snake.id}/delete/' response = self.client.get(url) self.assertEqual(response.status_code, 302) # for admin self.client.login(username='******', password='******') response = self.client.get(url) self.assertEqual(response.status_code, 200) self.client.logout() # for staff self.client.login(username='******', password='******') response = self.client.get(url) self.assertEqual(response.status_code, 403) url = '/create/' response = self.client.get(url) self.assertEqual(response.status_code, 200) self.client.logout() # for user self.client.login(username='******', password='******') url = '/create/' response = self.client.get(url) self.assertEqual(response.status_code, 403) self.client.logout()
class TestImagesViews(TestCase): """Class to test image views.""" @classmethod def setUp(self): user = User(username='******', email='*****@*****.**') user.save() self.user = user self.client = Client() photo = PhotoFactory.build() photo.user_id = self.user.id photo.save() self.photo = photo album = AlbumFactory.build() album.user_id = self.user.id album.save() self.album = album self.request = RequestFactory() @classmethod def tearDown(self): """Teardown class for test users.""" User.objects.all().delete() super(TestCase, self) def test_200_status_on_authenticated_request_to_library(self): """Check for 200 status code.""" self.client.force_login(self.user) response = self.client.get(reverse_lazy('library')) self.client.logout() self.assertEqual(response.status_code, 200) def test_302_status_on_unauthenticated_request_to_library(self): """Check for 302 status code.""" response = self.client.get(reverse_lazy('library')) self.assertEqual(response.status_code, 302) def test_get_library_page_404_status_code(self): """Test library page view returns 404 status code.""" self.client.force_login(self.user) response = self.client.get('images/libary/', follow=True) self.assertEqual(response.status_code, 404) def test_get_library_page_templates(self): """Test library page view templates.""" self.client.force_login(self.user) response = self.client.get(reverse_lazy('library'), follow=True) self.assertEqual(response.templates[0].name, 'images/library.html') self.assertEqual(response.templates[1].name, 'base.html') def test_200_status_on_authenticated_request_to_albums(self): """Check for 200 status code.""" self.client.force_login(self.user) response = self.client.get(reverse_lazy('albums')) self.client.logout() self.assertEqual(response.status_code, 200) def test_302_status_on_unauthenticated_request_to_albums(self): """Check for 302 status code.""" response = self.client.get(reverse_lazy('albums')) self.assertEqual(response.status_code, 302) def test_get_albums_page_404_status_code(self): """Test library page view returns 404 status code.""" self.client.force_login(self.user) response = self.client.get('images/alum', follow=True) self.assertEqual(response.status_code, 404) def test_get_album_page_templates(self): """Test library page view templates.""" self.client.force_login(self.user) response = self.client.get(reverse_lazy('albums'), follow=True) self.assertEqual(response.templates[0].name, 'images/albums.html') self.assertEqual(response.templates[1].name, 'base.html') def test_200_status_on_authenticated_request_to_photos(self): """Check for 200 status code.""" self.client.force_login(self.user) response = self.client.get(reverse_lazy('photos')) self.client.logout() self.assertEqual(response.status_code, 200) def test_302_status_on_unauthenticated_request_to_photos(self): """Check for 302 status code.""" response = self.client.get(reverse_lazy('photos')) self.assertEqual(response.status_code, 302) def test_get_photos_page_404_status_code(self): """Test library page view returns 404 status code.""" self.client.force_login(self.user) response = self.client.get('images/photogs/', follow=True) self.assertEqual(response.status_code, 404) def test_get_photos_page_templates(self): """Test library page view templates.""" self.client.force_login(self.user) response = self.client.get(reverse_lazy('photos'), follow=True) self.assertEqual(response.templates[0].name, 'images/photos.html') self.assertEqual(response.templates[1].name, 'base.html') def test_200_status_on_authenticated_request_to_image(self): """Test 200 status code on authenticated request to single image.""" self.client.force_login(self.user) response = self.client.get('/images/photos/{}'.format(self.photo.id)) self.client.logout() self.assertEqual(response.status_code, 200) def test_302_status_on_unauthenticated_request_to_image(self): """Test 200 status code on authenticated request to single image.""" response = self.client.get('/images/photos/{}'.format(self.photo.id)) self.assertEqual(response.status_code, 302) def test_404_status_on_bad_request_to_image(self): """Test bad photo page view returns 404 status code.""" response = self.client.get('/images/photos/does_not_exist') self.assertEqual(response.status_code, 404) def test_get_photo_edit_page_templates(self): """Test library page view templates.""" self.client.force_login(self.user) response = self.client.get('/images/photos/{}/edit'.format( self.photo.id)) self.assertEqual(response.templates[0].name, 'images/photo_edit.html') self.assertEqual(response.templates[1].name, 'base.html') def test_200_status_on_authenticated_request_to_edit_image(self): """Test 200 status code on authenticated request to edit album page.""" self.client.force_login(self.user) response = self.client.get('/images/photos/{}/edit'.format( self.photo.id)) self.client.logout() self.assertEqual(response.status_code, 200) def test_302_status_on_unauthenticated_request_to_edit_image(self): """Test 302 status code on unauthenticated request to edit album page.""" response = self.client.get('/images/photos/{}/edit'.format( self.photo.id)) self.assertEqual(response.status_code, 302) def test_unauth_user_redirected_to_login_on_photo_edit_page(self): """Test unauthorized user is redirected to login page.""" response = self.client.get('/images/photos/{}/edit'.format( self.photo.id), follow=True) self.assertEqual(response.templates[0].name, 'registration/login.html') self.assertEqual(response.templates[1].name, 'base.html') def test_200_status_on_authenticated_request_to_album(self): """Test 200 status code on authenticated request to single album.""" self.client.force_login(self.user) response = self.client.get('/images/albums/{}'.format(self.album.id)) self.client.logout() self.assertEqual(response.status_code, 200) def test_302_status_on_unauthenticated_request_to_album(self): """Test 302 status code on unauthenticated request to single album.""" response = self.client.get('/images/albums/{}'.format(self.album.id)) self.assertEqual(response.status_code, 302) def test_404_status_on_bad_request_to_album(self): """Test bad photo page view returns 404 status code.""" response = self.client.get('/images/albums/does_not_exist') self.assertEqual(response.status_code, 404) def test_200_status_on_authenticated_request_to_edit_album(self): """Test 200 status code on authenticated request to edit album page.""" self.client.force_login(self.user) response = self.client.get('/images/albums/{}/edit'.format( self.album.id)) self.client.logout() self.assertEqual(response.status_code, 200) def test_302_status_on_unauthenticated_request_to_edit_album(self): """Test 302 status code on unauthenticated request to edit album page.""" response = self.client.get('/images/albums/{}/edit'.format( self.album.id)) self.assertEqual(response.status_code, 302) def test_unauth_user_redirected_to_login_on_album_edit_page(self): """Test unauthorized user is redirected to login page.""" response = self.client.get('/images/albums/{}/edit'.format( self.album.id), follow=True) self.assertEqual(response.templates[0].name, 'registration/login.html') self.assertEqual(response.templates[1].name, 'base.html')
class UserProfileTests(TestCase): def setUp(self): self.newuser = get_user_model().objects.create_user( email='*****@*****.**', password='******', short_name='new', full_name='new user') self.client = Client() self.basedir = os.path.dirname(os.path.dirname(__file__)) def login_newuser(self): self.client.logout() response = self.client.post(reverse('friendly_login'), { 'username': '******', 'password': '******' }) self.assertEqual(response.status_code, 302) return response def post_with_profile_picture(self, formdata, code=302): path_to_pic = os.path.join(self.basedir, 'fixtures/aristotle.png') with open(path_to_pic, mode='br') as fp: formdata.update({'profile_picture': fp}) response = self.client.post(reverse('aristotle_mdr:userEdit'), formdata) self.assertEqual(response.status_code, code) return response def get_initial(self): response = self.client.get(reverse('aristotle_mdr:userEdit')) self.assertEqual(response.status_code, 200) # Get initial form data initial = response.context['form'].initial return initial def test_load_profile(self): self.login_newuser() response = self.client.get(reverse('aristotle_mdr:userProfile')) self.assertEqual(response.status_code, 200) def test_load_profile_content(self): self.login_newuser() response = self.client.get(reverse('aristotle_mdr:userProfile')) # check dynamic picture loaded dynamic_picture_url = reverse('aristotle_mdr:dynamic_profile_picture', args=[self.newuser.id]) self.assertContains(response, dynamic_picture_url) # check sessions context self.assertEqual(len(response.context['sessions']), 1) def test_load_edit_page(self): self.login_newuser() response = self.client.get(reverse('aristotle_mdr:userEdit')) self.assertEqual(response.status_code, 200) # Check initial is set properly initial = response.context['form'].initial self.assertEqual(initial['email'], '*****@*****.**') self.assertEqual(initial['short_name'], 'new') self.assertEqual(initial['full_name'], 'new user') self.assertFalse('profilePicture' in initial) def test_profile_upload(self): self.login_newuser() initial = self.get_initial() response = self.post_with_profile_picture(initial) user = get_user_model().objects.get(email='*****@*****.**') self.assertTrue(user.profile.profilePicture) self.assertTrue( user.profile.profilePicture.name.startswith('aristotle')) self.assertEqual(user.profile.profilePictureWidth, 256) self.assertTrue(user.profile.profilePictureHeight) def test_profile_upload_with_clear(self): self.login_newuser() initial = self.get_initial() initial.update({'profile_picture-clear': 'on'}) response = self.client.post(reverse('aristotle_mdr:userEdit'), initial) def test_save_without_changes(self): self.login_newuser() initial = self.get_initial() response = self.post_with_profile_picture(initial) # Post form again, with no changes complete_initial = self.get_initial() response = self.client.post(reverse('aristotle_mdr:userEdit'), complete_initial) self.assertEqual(response.status_code, 302) def test_default_profile_picture(self): # check page load response = self.client.get( reverse('aristotle_mdr:dynamic_profile_picture', args=[3])) self.assertEqual(response.status_code, 200) three_toga_color = response.context['toga_color'] three_headshot_color = response.context['headshot_color'] # check diffent args returns new colors response = self.client.get( reverse('aristotle_mdr:dynamic_profile_picture', args=[4])) self.assertEqual(response.status_code, 200) self.assertNotEqual(three_toga_color, response.context['toga_color']) self.assertNotEqual(three_headshot_color, response.context['headshot_color']) # check second request with same args returns same colors response = self.client.get( reverse('aristotle_mdr:dynamic_profile_picture', args=[3])) self.assertEqual(response.status_code, 200) self.assertEqual(three_toga_color, response.context['toga_color']) self.assertEqual(three_headshot_color, response.context['headshot_color'])
class ViewsHomeTest(TestCase): fixtures = ['init', 'crontab', 'test-rules-source'] def setUp(self): self.client = Client() User.objects.create_superuser(username='******', password='******', email='*****@*****.**') if not self.client.login(username='******', password='******'): self.assertRaises(Exception("Not logged")) def tearDown(self): self.client.logout() def test_login(self): """ Django Admin login """ response = self.client.get('/admin/login/', follow=True) self.assertEqual(response.status_code, 200) self.assertIn( '<title>Site administration | Probe Manager site admin</title>', str(response.content)) self.assertEqual('admin/index.html', response.templates[0].name) self.assertIn('admin', response.resolver_match.app_names) self.assertIn('function AdminSite.index', str(response.resolver_match.func)) response = self.client.get('/admin/') self.assertEqual(response.status_code, 200) self.assertIn( '<a href="/admin/auth/user/" class="changelink">Change</a>', str(response.content)) self.assertEqual(str(response.context['user']), 'testuser') with self.assertTemplateUsed('admin/index.html'): self.client.get('/admin/login/', follow=True) client_not_logged = Client() response = client_not_logged.get('/admin/login/', follow=True) self.assertEqual(response.status_code, 200) self.assertIn('<title>Log in | Probe Manager site admin</title>', str(response.content)) response = client_not_logged.get('/admin/', follow=True) self.assertEqual(response.status_code, 200) self.assertIn('<title>Log in | Probe Manager site admin</title>', str(response.content)) self.assertEqual(str(response.context['user']), 'AnonymousUser') response = client_not_logged.get('/admin/') self.assertRedirects(response, expected_url='/admin/login/?next=/admin/', status_code=302, target_status_code=200) with self.assertTemplateUsed('admin/login.html'): client_not_logged.get('/admin/', follow=True) def test_index(self): """ Home page """ response = self.client.get('/') self.assertEqual(response.status_code, 200) self.assertIn('<title>Home</title>', str(response.content)) self.assertEqual('home/index.html', response.templates[0].name) self.assertIn('home', response.resolver_match.app_names) self.assertIn('function index', str(response.resolver_match.func)) self.assertEqual(str(response.context['user']), 'testuser') with self.assertTemplateUsed('home/index.html'): self.client.get('/')
class EventTest(TestCase): fixtures = ['user.json', 'socialapp.json'] def setUp(self): self.client = Client() self.event_data = EVENT_DATA.copy() self.proposal_data = PROPOSAL_DATA.copy() self.client.login(username='******', password='******') def test_create_event(self): response = self.client.post(reverse('create_event'), self.event_data, follow=True) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(Event.objects.all(), ["<Event: RuPy>"]) self.assertQuerysetEqual(response.context['request'].user.events.all(), ["<Event: RuPy>"]) event = response.context['event'] self.assertEquals('RuPy', event.title) self.assertEquals('A really good event.', event.description) self.assertEquals('admin', event.author.username) self.assertEquals(False, event.is_published) def test_notify_event_creator_after_creation(self): self.client.post(reverse('create_event'), self.event_data) event = Event.objects.get() self.assertEqual(1, len(mail.outbox)) email = mail.outbox[0] self.assertIn(event.author.email, email.recipients()) self.assertIn(settings.NO_REPLY_EMAIL, email.from_email) def test_create_event_with_jury(self): event_data = self.event_data.copy() response = self.client.post(reverse('create_event'), event_data, follow=True) self.assertEquals(200, response.status_code) event = response.context['event'] self.assertEquals(Jury.objects.count(), 1) self.assertQuerysetEqual(event.jury.users.all(), ['<User: admin>']) def test_anonymous_user_create_events(self): self.client.logout() response = self.client.post(reverse('create_event'), self.event_data, follow=True) self.assertEquals(200, response.status_code) self.assertEquals(reverse('create_event'), response.context_data.get('redirect_field_value')) self.assertEquals(0, Event.objects.count()) def test_empty_list_event(self): self.client.login(username='******', password='******') Event.objects.create(**self.event_data) response = self.client.get(reverse('list_events'), follow=True) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_list'], []) def test_list_event(self): event_data = self.event_data.copy() event_data.update(is_published=True) Event.objects.create(**event_data) response = self.client.get(reverse('list_events'), follow=True) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(response.context['event_list'], ["<Event: RuPy>"]) def test_detail_event(self): event = Event.objects.create(**self.event_data) response = self.client.get( reverse('view_event', kwargs={'slug': event.slug}), follow=True ) self.assertEquals(200, response.status_code) event = response.context['event'] self.assertEquals('RuPy', event.title) self.assertEquals('A really good event.', event.description) def test_detail_from_an_event_with_now_allow_public_voting(self): self.client.logout() event_data = self.event_data.copy() event_data.update(allow_public_voting=False) event = Event.objects.create(**event_data) response = self.client.get( reverse('view_event', kwargs={'slug': event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual([], response.context['event_proposals']) def test_update_event(self): event = Event.objects.create(**self.event_data) self.assertEquals(1, Event.objects.count()) new_event_data = self.event_data.copy() new_event_data['description'] = 'A really really good event.' self.assertEquals(self.event_data['description'], event.description) response = self.client.post(reverse('update_event', kwargs={'slug': event.slug}), new_event_data, follow=True) self.assertEquals(200, response.status_code) event = response.context['event'] self.assertEquals('RuPy', event.title) self.assertEquals('A really really good event.', event.description) def test_update_event_title(self): event = Event.objects.create(**self.event_data) new_event_data = self.event_data.copy() new_event_data['title'] = 'RuPy 2014' self.assertEquals(self.event_data['title'], event.title) response = self.client.post( reverse('update_event', kwargs={'slug': event.slug}), new_event_data, follow=True ) self.assertEquals(200, response.status_code) event = response.context['event'] self.assertEquals('rupy-2014', event.slug) def test_anonymous_user_update_events(self): self.client.logout() event = Event.objects.create(**self.event_data) event_update_url = reverse('update_event', kwargs={'slug': event.slug}) new_event_data = self.event_data.copy() new_event_data['title'] = 'RuPy 2014' response = self.client.post( event_update_url, new_event_data, follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(event_update_url, response.context_data.get('redirect_field_value')) self.assertEquals('RuPy', event.title) def test_not_author_update_events(self): self.client.login(username='******', password='******') event = Event.objects.create(**self.event_data) event_update_url = reverse('update_event', kwargs={'slug': event.slug}) new_event_data = self.event_data.copy() new_event_data['title'] = 'RuPy 2014' response = self.client.post( event_update_url, new_event_data, follow=True ) self.assertEquals(200, response.status_code) self.assertEquals('event/event_detail.html', response.template_name[0]) self.assertEquals('RuPy', event.title) def test_publish_event(self): event = Event.objects.create(**self.event_data) event_data = self.event_data.copy() event_data['is_published'] = True self.assertEquals(False, event.is_published) response = self.client.post( reverse('update_event', kwargs={'slug': event.slug}), event_data, follow=True ) self.assertEquals(200, response.status_code) event = response.context['event'] self.assertEquals(True, event.is_published) def test_event_create_event_proposal_context(self): event = Event.objects.create(**self.event_data) response = self.client.get( reverse('create_event_proposal', kwargs={'slug': event.slug}), follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(event, response.context['event']) def test_event_create_event_proposal(self): event = Event.objects.create(**self.event_data) response = self.client.post( reverse('create_event_proposal', kwargs={'slug': event.slug}), self.proposal_data, follow=True ) self.assertEquals(200, response.status_code) self.assertQuerysetEqual(Proposal.objects.all(), ["<Proposal: Python For Zombies>"]) self.assertQuerysetEqual(event.proposals.all(), ["<Proposal: Python For Zombies>"]) python_for_zombies = event.proposals.get() self.assertEquals('Python For Zombies', python_for_zombies.title) self.assertEquals('Brain...', python_for_zombies.description) def test_notify_event_jury_and_proposal_author_on_new_proposal(self): event = Event.objects.create(**self.event_data) self.client.post( reverse('create_event_proposal', kwargs={'slug': event.slug}), self.proposal_data, follow=True ) proposal = event.proposals.get() self.assertEqual(2, len(mail.outbox)) jury_email = mail.outbox[0] for jury in event.jury.users.all(): self.assertIn(jury.email, jury_email.recipients()) self.assertIn(settings.NO_REPLY_EMAIL, jury_email.from_email) author_email = mail.outbox[0] self.assertIn(proposal.author.email, author_email.recipients()) self.assertIn(settings.NO_REPLY_EMAIL, author_email.from_email) def test_anonymous_user_create_event_proposal(self): event = Event.objects.create(**self.event_data) self.client.logout() event_create_proposal_url = reverse( 'create_event_proposal', kwargs={'slug': event.slug}) response = self.client.post( event_create_proposal_url, self.proposal_data, follow=True ) self.assertEquals(200, response.status_code) self.assertEquals(event_create_proposal_url, response.context_data.get('redirect_field_value')) self.assertEquals(0, event.proposals.count()) def test_event_create_event_proposal_with_passed_due_date(self): event_data = self.event_data.copy() event_data.update(due_date=datetime.now() - timedelta(hours=24)) event = Event.objects.create(**event_data) with self.assertRaises(ValidationError): self.client.post( reverse('create_event_proposal', kwargs={'slug': event.slug}), self.proposal_data ) self.assertEquals(0, event.proposals.count()) response = self.client.get( reverse('create_event_proposal', kwargs={'slug': event.slug})) self.assertEqual(302, response.status_code) def test_export_votes_to_csv_queryset(self): event = Event.objects.create(**self.event_data) Proposal.objects.create(event=event, **self.proposal_data) proposals = event.get_votes_to_export() exported_data = [{'title': u'Python For Zombies', 'votes__count': 0, 'author__email': u'*****@*****.**', 'author__username': u'admin', 'votes__rate__sum': None, 'id': 1}] self.assertEqual(list(proposals), exported_data) def test_export_votes_sum_rate(self): event = Event.objects.create(**self.event_data) proposal = Proposal.objects.create(event=event, **self.proposal_data) user = User.objects.get(username='******') another_user = User.objects.get(username='******') Vote.objects.create(user=user, proposal=proposal, rate=2) Vote.objects.create(user=another_user, proposal=proposal, rate=-1) proposals = list(event.get_votes_to_export()) sum_rate = sum(proposal['votes__rate__sum'] for proposal in proposals) self.assertEqual(1, sum_rate) def test_export_votes_count(self): event = Event.objects.create(**self.event_data) proposal = Proposal.objects.create(event=event, **self.proposal_data) user = User.objects.get(username='******') another_user = User.objects.get(username='******') Vote.objects.create(user=user, proposal=proposal, rate=1) Vote.objects.create(user=another_user, proposal=proposal, rate=1) proposals = list(event.get_votes_to_export()) total_votes = sum(proposal['votes__count'] for proposal in proposals) self.assertEqual(2, total_votes) def test_export_event_votes_to_csv(self): event = Event.objects.create(**self.event_data) response = self.client.get( reverse('export_event', kwargs={'slug': event.slug})) self.assertEqual(response.status_code, 200) self.assertEqual(response['Content-Type'], 'text/csv') def test_not_authorized_to_export_event_votes_to_csv(self): self.client.login(username='******', password='******') event = Event.objects.create(**self.event_data) response = self.client.get( reverse('export_event', kwargs={'slug': event.slug})) self.assertEqual(302, response.status_code)
def test_subscribe(self): # Start client as admin broker = { 'HOST': settings.MQTT['BROKER_TEST_HOST'], 'PORT': 1883, 'KEEPALIVE': 60, 'CLEAN_SESSION': True } # Start subscribe client broker.update(settings.MQTT) broker['CLIENT_ID'] = 'test_subscribe_1' subscribe_client = SubscribeClient(broker, debug=True) self.is_connected(subscribe_client) self.is_subscribed(subscribe_client) # Start test client broker.update(settings.MQTT) client_id = 'test_subscribe_2' username = broker['USERNAME'] broker['CLIENT_ID'] = client_id test_client = MQTTTestClient(broker, check_payload=False, debug=True) self.is_connected(test_client) # start django client django_client = DjangoClient() # login as admin django_client.login(username=settings.MQTT['USERNAME'], password=settings.MQTT['PASSWORD']) # handshake ambulance and hospital response = django_client.post('/en/api/client/', content_type='application/json', data=json.dumps({ 'client_id': client_id, 'status': ClientStatus.O.name, 'ambulance': self.a1.id, 'hospital': self.h1.id }), follow=True) self.assertEqual(response.status_code, 201) # check record clnt = Client.objects.get(client_id=client_id) self.assertEqual(clnt.status, ClientStatus.O.name) self.assertEqual(clnt.ambulance, self.a1) self.assertEqual(clnt.hospital, self.h1) # Modify ambulance # retrieve current ambulance status obj = Ambulance.objects.get(id=self.a1.id) self.assertEqual(obj.status, AmbulanceStatus.UK.name) # expect update once test_client.expect('ambulance/{}/data'.format(self.a1.id)) self.is_subscribed(test_client) # publish change test_client.publish('user/{}/client/{}/ambulance/{}/data'.format( self.u1.username, client_id, self.a1.id), json.dumps({ 'status': AmbulanceStatus.OS.name, }), qos=0) # process messages self.loop(test_client, subscribe_client) # verify change obj = Ambulance.objects.get(id=self.a1.id) self.assertEqual(obj.status, AmbulanceStatus.OS.name) # Modify hospital # retrieve current hospital status obj = Hospital.objects.get(id=self.h1.id) self.assertEqual(obj.comment, 'no comments') # expect update once test_client.expect('hospital/{}/data'.format(self.h1.id)) self.is_subscribed(test_client) test_client.publish('user/{}/client/{}/hospital/{}/data'.format( self.u1.username, client_id, self.h1.id), json.dumps({ 'comment': 'no more comments', }), qos=0) # process messages self.loop(test_client, subscribe_client) # verify change obj = Hospital.objects.get(id=self.h1.id) self.assertEqual(obj.comment, 'no more comments') # Modify hospital equipment # retrieve current equipment value obj = EquipmentItem.objects.get( equipmentholder=self.h1.equipmentholder, equipment=self.e1) self.assertEqual(obj.value, 'True') # expect update once test_client.expect('equipment/{}/item/{}/data'.format( self.h1.equipmentholder.id, self.e1.id)) self.is_subscribed(test_client) test_client.publish( 'user/{}/client/{}/equipment/{}/item/{}/data'.format( self.u1.username, client_id, self.h1.equipmentholder.id, self.e1.id), json.dumps({ 'value': 'False', }), qos=0) # process messages self.loop(test_client, subscribe_client) # verify change obj = EquipmentItem.objects.get( equipmentholder=self.h1.equipmentholder, equipment=self.e1) self.assertEqual(obj.value, 'False') # test bulk ambulance update # expect null client after logout test_client.expect('ambulance/{}/data'.format(self.a1.id)) self.is_subscribed(test_client) # handshake ambulance response = django_client.post('/en/api/client/', content_type='application/json', data=json.dumps({ 'client_id': client_id, 'status': ClientStatus.O.name, 'ambulance': self.a2.id, }), follow=True) # result = JSONParser().parse(BytesIO(response.content)) # logger.debug(result) self.assertEqual(response.status_code, 201) # check record clnt = Client.objects.get(client_id=client_id) self.assertEqual(clnt.status, ClientStatus.O.name) self.assertEqual(clnt.ambulance, self.a2) self.assertEqual(clnt.hospital, self.h1) # retrieve last ambulance obj = Ambulance.objects.get(id=self.a1.id) self.assertEqual(hasattr(obj, 'client'), False) # retrieve current ambulance status obj = Ambulance.objects.get(id=self.a2.id) self.assertEqual(obj.status, AmbulanceStatus.UK.name) location = {'latitude': -2., 'longitude': 7.} timestamp = timezone.now() data = [{ 'status': AmbulanceStatus.OS.name, }, { 'status': AmbulanceStatus.AV.name, 'location': location, }, { 'status': AmbulanceStatus.PB.name, 'timestamp': str(timestamp) }] # expect update once test_client.expect('ambulance/{}/data'.format(self.a2.id)) self.is_subscribed(test_client) test_client.publish('user/{}/client/{}/ambulance/{}/data'.format( self.u1.username, client_id, self.a2.id), json.dumps(data), qos=0) # process messages self.loop(test_client, subscribe_client) # verify change obj = Ambulance.objects.get(id=self.a2.id) self.assertEqual(obj.status, AmbulanceStatus.PB.name) self.assertEqual(obj.timestamp, timestamp) self.assertEqual(point2str(obj.location), point2str(location)) # Client handshake test_client.publish( 'user/{}/client/{}/status'.format(username, client_id), ClientStatus.F.name) # process messages self.loop(test_client, subscribe_client) # check record clnt = Client.objects.get(client_id=client_id) self.assertEqual(clnt.status, ClientStatus.F.name) self.assertEqual(clnt.ambulance, None) self.assertEqual(clnt.hospital, None) # wait for disconnect test_client.wait() subscribe_client.wait() django_client.logout()
class UserViewsTestCase(TestCase): """Test app user views""" def setUp(self): self.user = User.objects.create_user(username='******', first_name='test', last_name='test', email='*****@*****.**', password='******') self.raise_awareness_group = Group.objects.create(name='Sensibiliser') self.raise_awareness_user = User.objects.create_user( username='******', first_name='test', last_name='test', email='*****@*****.**', password='******') self.raise_awareness_user.groups.add(self.raise_awareness_group) self.want_to_understand_group = Group.objects.create(name='Comprendre') self.want_to_understand_user = User.objects.create_user( username='******', first_name='test', last_name='test', email='*****@*****.**', password='******') self.want_to_understand_user.groups.add(self.want_to_understand_group) self.disorder = Disorder.objects.create(name="test", details="test", url_pattern="test") self.request = Request.objects.create( disorder=self.disorder, message="test", user=self.want_to_understand_user, status=0) self.client = Client() def test_login_page(self): """Check that login page returns status code 200""" response = self.client.get(reverse('app:login')) self.assertEqual(response.status_code, 200) def test_logout(self): """Check that logout page returns status code 200""" self.client.login(username='******', password='******') self.client.logout() response = self.client.get(reverse('app:logout')) self.assertEqual(response.status_code, 302) def test_account(self): """Check that personnal account page returns status code 200""" self.client.login(username='******', password='******') response = self.client.get(reverse('app:account')) self.assertEqual(response.status_code, 200) def test_create_account(self): """Check that create account page returns status code 200""" response = self.client.get(reverse('app:create_account')) self.assertEqual(response.status_code, 200) def test_delete_account(self): """Check that user can delete his account""" self.client.login(username='******', password='******') users_count = len(User.objects.all()) response = self.client.get(reverse('app:delete_account'), follow=True) new_users_count = len(User.objects.all()) self.assertEqual(response.status_code, 200) self.assertRedirects(response, '/') self.assertEqual(new_users_count, users_count - 1) def test_access_account_raise_awareness(self): """Check that personnal account contains raise awareness user specific data""" self.client.login(username='******', password='******') response = self.client.get(reverse('app:account')) self.assertContains( response, '<a class="btn btn-primary" href="/testify/">Je veux témoigner</a>' ) def test_access_account_want_to_understand(self): """Check that personnal account contains want to understand user specific data""" self.client.login(username='******', password='******') response = self.client.get(reverse('app:account')) self.assertContains( response, '<a class="btn btn-primary" href="/request/">Créer une requếte</a>' ) def test_login_view(self): """Check that login form is validated and user is logged in""" response = self.client.post('/login/', { 'username': '******', 'password': '******' }, follow=True) self.assertTrue(response.context['user'].is_active) self.assertRedirects(response, '/account/') def test_account_creation_view(self): """Check that account creation form is validated, new user is added to database and is redirected to thanks page""" user_count = len(User.objects.all()) response = self.client.post('/new-user/', { 'username': '******', 'password': '******', 'email': '*****@*****.**', 'first_name': 'new', 'last_name': 'new', 'groups': self.raise_awareness_group }, follow=True) new_user_count = len(User.objects.all()) self.assertEqual(user_count + 1, new_user_count) self.assertEqual(response.status_code, 200) self.assertRedirects(response, '/rules/') def test_rules_view(self): """Check that thanks for creating an account and community rules page returns status code 200""" response = self.client.get(reverse('app:rules')) self.assertEqual(response.status_code, 200) def test_new_request_view(self): """Check that request creation form is validated, new request is added to database and user is redirected to his account""" self.client.login(username='******', password='******') response = self.client.get(reverse('app:request')) self.assertEqual(response.status_code, 200) request_count = len(Request.objects.all()) response = self.client.post('/request/', { 'message': 'test', 'disorders': self.disorder }, follow=True) new_request_count = len(Request.objects.all()) self.assertEqual( Request.objects.latest('id').user, self.want_to_understand_user) self.assertEqual(request_count + 1, new_request_count) self.assertEqual(response.status_code, 200) self.assertRedirects(response, '/account/') def test_new_testimony_view(self): """Check that testimony creation form is validated, new testimony is added to database and user is redirected to his account""" self.client.login(username='******', password='******') response = self.client.get(reverse('app:testify')) self.assertEqual(response.status_code, 200) testimony_count = len(Testimony.objects.all()) response = self.client.post('/testify/', { 'content': 'test', 'disorders': self.disorder }, follow=True) new_testimony_count = len(Testimony.objects.all()) self.assertEqual( Testimony.objects.get(pk=1).user, self.raise_awareness_user) self.assertEqual(testimony_count + 1, new_testimony_count) self.assertEqual(response.status_code, 200) self.assertRedirects(response, '/account/') def test_requests_list_page(self): """Check that requests list is displayed""" self.client.login(username='******', password='******') response = self.client.get(reverse('app:requests_list')) self.assertEqual(response.status_code, 200) def test_request_info(self): self.client.login(username='******', password='******') response = self.client.get( reverse('app:request_info', args=[self.request.pk])) self.assertEqual(response.status_code, 200) def test_accept_request(self): """Check that accepting a request redirects user to account and that requests status is changed""" self.client.login(username='******', password='******') response = self.client.get(reverse('app:accept_request', args=[self.request.pk]), follow=True) self.request.refresh_from_db() self.assertEqual(response.status_code, 200) self.assertEqual(self.request.awareness_user, self.raise_awareness_user) self.assertRedirects(response, '/account/') self.assertEqual(self.request.status, 1) def test_awareness_user_requests_list_page(self): """Check that awareness user requests list is displayed when accepted""" self.client.login(username='******', password='******') self.client.get(reverse('app:accept_request', args=[self.request.pk]), follow=True) response = self.client.get(reverse('app:user_requests_list')) self.assertEqual(response.status_code, 200) for request in response.context["requests"]: self.assertEqual(request.status, 1) self.assertEqual(request.user, self.want_to_understand_user) self.assertEqual(request.awareness_user, self.raise_awareness_user) def test_understand_user_requests_list_page(self): """Check that understand user requests list is displayed when accepted""" self.client.login(username='******', password='******') self.client.get(reverse('app:accept_request', args=[self.request.pk]), follow=True) response = self.client.get(reverse('app:user_requests_list')) self.assertEqual(response.status_code, 200) for request in response.context["requests"]: self.assertEqual(request.user, self.want_to_understand_user)