class Mixin(object): '''This class provides names and data common to all the tests in this module. ''' fixtures = ['test_auth.json'] tearDown = staticmethod(anthropod.tests.teardown) maxDiff = None def setUp(self): '''Load test fixtures and log in before running the tests.''' load_test_fixtures() self.client = Client() self.client.login(**self.login_credentials) self.db = anthropod.core.db params = [ (u'contact_type', ['address', u'cell']), (u'contact_note', ['Not a real address', u'Fake phone']), (u'contact_value', ['123 Example Street', u'(123)456-7890']), (u'source_url', [ 'http://mayor.cityofboise.org/city-council/', u'https://sunfoundation.com' ]), (u'source_note', [ '', u"Sunlight's url" ]), (u'geography_id', u'ocd-division/country:us/state:id/place:boise_city'), (u'name', u'City Council') ]
def test_rechazar_solicitud(self): c = Client() c.login(username='******', password='******') url = reverse('solicitudCambio.views.rechazar_solicitud', args=[self.solicitud.id]) response = c.get(url) url_retorno = reverse('solicitudCambio.views.listar_solicitudes') self.assertRedirects(response, url_retorno)
def skip_test_should_service_authenticated_user(self): c = Client() c.login(username='******', password='******') response = c.get(reverse('scrumboard:item_create')) assert response.status_code == 200
class ProjectMapLocationTest(TestCase): """.""" def setUp(self): """Setup test cast. 1. Create user 2. Create auth group for REST API access 3. Add the user to the created group 4. Save a test Client with the correct HOST(needed because of our dispatch middleware) """ u = User.objects.create(username="******", password="******", is_staff=True, is_active=True, is_superuser=True) u.save() API_users = Group.objects.create(id=8, name="Full REST API access") API_users.save() API_users.user_set.add(u) self.c = Client(HTTP_HOST=settings.RSR_DOMAIN) def test_one(self): """Test the name & the unicode method.""" self.c.login(username='******', password='******') resp = self.c.get('/rest/v1/project_map_location/', {'format': 'json'}) self.assertEqual(resp.status_code, 200)
def get_logged_in_client(self, username=None, password=None): if not username: username = self.TEST_USERNAME if not password: password = self.TEST_PASSWORD client = Client() client.login(username=username, password=password) return client
def get_logged_in_trudy_client(self): client = Client() client.login( username=TEST_USER_USERNAME2, password=TEST_USER_PASSWORD2 ) return client
class HomePageViewTest(BaseTest): def setUp(self): self.client = Client() self.user, self.country = self.create_user_with_no_permissions() self.assign('can_submit_responses', self.user) self.client.login(username=self.user.username, password='******') def test_get(self): response = self.client.get("/") self.assertEqual(200, response.status_code) templates = [template.name for template in response.templates] self.assertIn('home/index.html', templates) def test_homepage_redirects_to_first_section_of_first_questionnaire_if_any_if_logged_in_as_data_submitter(self): questionnaire = Questionnaire.objects.create(name="JRF", description="bla") section = Section.objects.create(title="section", order=1, questionnaire=questionnaire, name="section") Section.objects.create(title="section", order=2, questionnaire=questionnaire, name="section") response = self.client.get("/") expected_url = "/questionnaire/entry/%d/section/%d/" % (questionnaire.id, section.id) self.assertRedirects(response, expected_url=expected_url) def test_login_required_for_home_get(self): self.assert_login_required('/')
def test_photo_view(self): photo = Photo.objects.all()[0] c = Client() c.login(username='******', password='******') response = c.get('/images/photos/{}/'.format(photo.id)) self.assertIn(photo.title, response.content) self.assertIn(photo.description, response.content)
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())
def test_basic_proxy_requests_from_proxied_content(self): client = Client() client.login(username='******', password='******') proxied_url = 'http://localhost' + reverse('wirecloud|proxy', kwargs={'protocol': 'http', 'domain': 'example.com', 'path': '/path'}) self.check_basic_requests(client, proxied_url)
def test_cookies(self): client = Client() client.login(username='******', password='******') client.cookies[str('test')] = 'test' def cookie_response(method, url, *args, **kwargs): if 'Cookie' in kwargs['headers']: return {'content': kwargs['headers']['Cookie'], 'headers': {'Set-Cookie': 'newcookie1=test; path=/, newcookie2=val1; path=/abc/d, newcookie3=c'}} else: return {'status_code': 404} self.network._servers['http']['example.com'].add_response('GET', '/path', cookie_response) response = client.get(self.basic_url, HTTP_HOST='localhost', HTTP_REFERER='http://localhost/test/workspace') self.assertEqual(response.status_code, 200) self.assertEqual(self.read_response(response), b'test=test') self.assertTrue('newcookie1' in response.cookies) self.assertEqual(response.cookies[str('newcookie1')].value, 'test') cookie_path = reverse('wirecloud|proxy', kwargs={'protocol': 'http', 'domain': 'example.com', 'path': '/'}) self.assertEqual(response.cookies[str('newcookie1')]['path'], cookie_path) self.assertTrue('newcookie2' in response.cookies) self.assertEqual(response.cookies[str('newcookie2')].value, 'val1') cookie_path = reverse('wirecloud|proxy', kwargs={'protocol': 'http', 'domain': 'example.com', 'path': '/abc/d'}) self.assertEqual(response.cookies[str('newcookie2')]['path'], cookie_path) self.assertTrue('newcookie3' in response.cookies) self.assertEqual(response.cookies[str('newcookie3')].value, 'c') cookie_path = reverse('wirecloud|proxy', kwargs={'protocol': 'http', 'domain': 'example.com', 'path': '/path'}) self.assertEqual(response.cookies[str('newcookie3')]['path'], cookie_path)
def test_request_with_workspace_referer_requires_permission(self): client = Client() client.login(username='******', password='******') response = client.get(self.basic_url, HTTP_HOST='localhost', HTTP_REFERER='http://localhost/test2/workspace') self.assertEqual(response.status_code, 403)
def test_basic_proxy_requests_from_widget(self): client = Client() client.login(username='******', password='******') widget_url = reverse('wirecloud.widget_code_entry', kwargs={"vendor": "Wirecloud", "name": "Test", "version": "1.0"}) self.check_basic_requests(client, 'http://localhost' + widget_url)
class FollowingTest(TestCase): fixtures = ['test_data.json'] def setUp(self): self.client = Client() self.user = User.objects.create_user('john', '*****@*****.**', 'johnpassword') self.client.login(username='******', password='******') def test_add_new_recommended_user(self): response = self.client.post('/twitter/recommended', {'twitter_screen_name': 'stefan'}) self.assertEqual(response.status_code, 200) new_user = FollowedUser.objects.get(twitter_screen_name='stefan') self.assertEqual(new_user.twitter_screen_name, 'stefan') def test_recommended_users_list(self): response = self.client.get('/twitter/recommended') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.context['followed_users_list']), 5) def test_list_followed_users(self): twython_mock = Mock() factory_mock = Mock() factory_mock.return_value = twython_mock twython_mock.get_friends_ids.return_value = {"ids": [1, 2]} twython_mock.lookup_user.return_value = [{"screen_name": "a"}, {"screen_name": "b"}] strategy = FollowedUsersStrategy(factory_mock) user_names = strategy.all_users(Mock()) self.assertEqual(user_names, [{'twitter_screen_name': 'a'}, {'twitter_screen_name': 'b'}]) def test_add_followed_user(self): twython_mock = Mock() factory_mock = Mock() factory_mock.return_value = twython_mock strategy = FollowedUsersStrategy(factory_mock) strategy.save(Mock(), Mock()) self.assertEqual(twython_mock.create_friendship.call_count, 1)
class ViewsTestCase(TestCase): def setUp(self): Group.objects.get_or_create(name="Student") Group.objects.get_or_create(name="Teacher") register_student("Navi_Smailliw", "makingRussiaStrong", "*****@*****.**", "Ivan", "Smailliw") setup_test_environment() self.client = Client() self.client.login(username="******", password="******") @patch('Exercise.views.get_assigned_exercise_for_students') def test_get_exercise_for_student(self, patch): patch.return_value = 'Dummy exercise' response = self.client.get(reverse(get_exercise_for_student)) self.assertEqual(200, response.status_code) self.assertTrue('exercises' in response.context) self.assertEqual('Dummy exercise', response.context['exercises']) @patch('Exercise.views.Exercise.objects.get') def test_student_single_exercise_editor(self, patch): patch.return_value = Exercise.objects.create(description='Dummy description') response = self.client.get(reverse(student_single_exercise_editor, args=('1',))) self.assertEqual(200, response.status_code) self.assertTrue('ex_description' in response.context) self.assertEqual('Dummy description', response.context['ex_description']) patch.assert_called_with(ex_id='1') def test_compile_code(self): pass #TODO
class TestUpdateUserPerms(TransactionTestCase): def setUp(self): self.client = Client() self.user = User.objects.create_user(username='******', password='******', first_name='Hodor', last_name='HodorHodor', email='*****@*****.**') Perms.objects.create(user=self.user, access_level=1).save() def test_update_user_perms(self): """Updating user permissions""" self.client.login(username='******', password='******') new_user = User.objects.create_user(username='******', password='******', first_name='Phillip', last_name='J Fry', email='*****@*****.**') #Test if perms are created for new user response = self.client.post('/users/perms/update/', data={'user_id': new_user.id, 'access_level': '5'}, follow=True) self.assertRedirects(response, '/users/view/%d/' % new_user.id) user = User.objects.get(pk=new_user.id) self.assertEquals(user.perms.access_level, 5) # Test updating once you have perms response = self.client.post('/users/perms/update/', data={'user_id': new_user.id, 'access_level': '2'}, follow=True) self.assertRedirects(response, '/users/view/%d/' % new_user.id) user = User.objects.get(pk=new_user.id) self.assertEquals(user.perms.access_level, 2)
class SettingsProcessorTestCase(TestCase): 'tests for settings processor' def setUp(self): 'prepare http client and a card for testing output' self.user = User.objects.create_user('user', '*****@*****.**', 'pass') self.client = Client() self.card = Biocard.objects.order_by('id')[0] if not self.card: self.card, created = Biocard.objects.get_or_create( first_name='first', last_name='last' ) def tearDown(self): User.objects.get(username='******').delete() def test_response_for_admin_edit_links(self): 'test output of edit_in_admin tags' self.client.login(username='******', password='******') print reverse(test_view) response = self.client.get(reverse(test_view)) self.assertContains( response, '/admin/about/biocard/%s/' % (self.card.id,), count=1, status_code=200 ) self.assertContains( response, '/admin/auth/user/%s/' % (self.user.id,), count=1, status_code=200 )
class TestContentParsingWithAuthentication(TestCase): urls = "djangorestframework.tests.content" def setUp(self): self.csrf_client = Client(enforce_csrf_checks=True) self.username = "******" self.email = "*****@*****.**" self.password = "******" self.user = User.objects.create_user(self.username, self.email, self.password) self.req = RequestFactory() def test_user_logged_in_authentication_has_post_when_not_logged_in(self): """Ensures request.POST exists after UserLoggedInAuthentication when user doesn't log in""" content = {"example": "example"} response = self.client.post("/", content) self.assertEqual(status.OK, response.status_code, "POST data is malformed") response = self.csrf_client.post("/", content) self.assertEqual(status.OK, response.status_code, "POST data is malformed") def test_user_logged_in_authentication_has_post_when_logged_in(self): """Ensures request.POST exists after UserLoggedInAuthentication when user does log in""" self.client.login(username="******", password="******") self.csrf_client.login(username="******", password="******") content = {"example": "example"} response = self.client.post("/", content) self.assertEqual(status.OK, response.status_code, "POST data is malformed") response = self.csrf_client.post("/", content) self.assertEqual(status.OK, response.status_code, "POST data is malformed")
class DashboardViewTests(TestCase): def setUp(self): self.client = Client() self.user1 = User.objects.create_user(username='******', password='******') def test_get_dashboard(self): self.client.login(username=self.user1.username, password='******') response = self.client.get('/dashboard/') self.assertEqual(response.status_code, 200) self.assertContains(response, 'Registered Device') def test_get_dashboard_while_not_logged_in(self): response = self.client.get('/dashboard/') print(response) self.assertEqual(response.status_code, 302) self.assertRegex(response.url, r'^.*/login/\?next=/dashboard/$') def test_post_new_device(self): self.client.login(username=self.user1.username, password='******') response = self.client.post('/dashboard/', data={ 'device_id': '12345678', 'device_name': 'test_device' }) self.assertEqual(response.status_code, 200) self.assertGreater(len(response.context['devices']), 0)
class ChangePasswordTestCase(TestCase): def setUp(self): self.my_user = User.objects.get(id=3) self.client = Client() def tearDown(self): self.my_user = None self.client = None def sign_in_first(self): return self.client.login(username=self.my_user.username, password="******") def test_user_should_login_first(self): # 'old_password', 'new_password1', 'new_password2' resp = self.client.post('/changepassword/', {'old_password': '******', 'new_password1': 'test', 'new_password2': 'test'}) self.assertEqual(resp.status_code, 302, "The user is redirected because he is not logged in") self.assertRedirects(resp, "/signin/?next=/changepassword/") def test_if_password_changed_user_redirected_to_profile(self): self.sign_in_first() resp = self.client.post('/changepassword/', {'old_password': '******', 'new_password1': 'test', 'new_password2': 'test'}) login_successful = self.client.login(username=self.my_user.username, password="******") self.assertTrue(login_successful) self.assertEqual(resp.status_code, 302) self.assertRedirects(resp, '/profile/') def test_password_form_sent_through_get_method(self): self.sign_in_first() resp = self.client.get('/changepassword/') self.assertEqual(resp.status_code, 200) self.assertTemplateUsed("changepassword.html")
class AlarmViewTest(TestCase): def setUp(self): self.client = Client() self.user = PyDayUser.objects._create_user("*****@*****.**", "secret", "MynameisWhat", "MynameisWho") self.client.login(email='*****@*****.**', password='******') def test_get(self): with self.assertTemplateUsed("create_alarm.html"): self.client.get(reverse("pyday_alarms:alarms")) def test_post(self): with self.assertTemplateUsed("error.html"): response = self.client.post(reverse("pyday_alarms:alarms"), {'date': '07/01/2016', 'hour': '1', 'mins': '0', 'message': 'haha'}, follow=True) self.assertContains(response, "Raspberry!") def test_post_invalid_form(self): with self.assertTemplateUsed("error.html"): response = self.client.post(reverse("pyday_alarms:alarms"), {}) self.assertContains(response, "Invalid form")
def test_moving_from_saved_basket_more_than_stocklevel_raises(self): user = User.objects.create_user(username='******', password='******', email='*****@*****.**') client = Client() client.login(username=user.username, password='******') product = create_product(price=D('10.00'), num_in_stock=1) basket, created = Basket.open.get_or_create(owner=user) basket.add_product(product=product, quantity=1) saved_basket, created = Basket.saved.get_or_create(owner=user) saved_basket.add_product(product=product, quantity=1) response = client.get(reverse('basket:summary')) saved_formset = response.context['saved_formset'] saved_form = saved_formset.forms[0] data = { saved_formset.add_prefix('INITIAL_FORMS'): 1, saved_formset.add_prefix('MAX_NUM_FORMS'): 1, saved_formset.add_prefix('TOTAL_FORMS'): 1, saved_form.add_prefix('id'): saved_form.initial['id'], saved_form.add_prefix('move_to_basket'): True, } response = client.post(reverse('basket:saved'), data=data) # we can't add more than stock level into basket self.assertEqual(Basket.open.get(id=basket.id).lines.get(product=product).quantity, 1) self.assertRedirects(response, reverse('basket:summary'))
class ArticleTest(TestCase): def setUp(self): self.client = Client() self.factory = RequestFactory() def test_validate_article_edition(self): user2 = User.objects.create_user(username="******", email="*****@*****.**", password="******") article = Article() article.title = "nicetitle" article.content = "nicecontent" article.create_user = user2 article.create_user.id = user2.id article.save() self.client.login(username="******", password="******") response = self.client.get(reverse('edit_article', kwargs={'id': '1'})) self.assertEqual(response.status_code, 302) response = self.client.post(reverse('edit_article', kwargs={'id': '1'})) self.assertEqual(response.status_code, 302) self.client.login(username="******", password="******") response = self.client.get(reverse('edit_article', kwargs={'id': '1'}), user=user2) self.assertEqual(response.status_code, 200) response = self.client.post(reverse('edit_article', kwargs={'id': '1'})) self.assertEqual(response.status_code, 200)
def test_widget_code_cache(self): client = Client() client.login(username='******', password='******') widget_id = {'vendor': 'Wirecloud', 'name': 'test', 'version': '0.1'} file_contents = self.build_simple_wgt('template1.xml', other_files=('images/catalogue.png', 'images/catalogue_iphone.png', 'doc/index.html')) added, resource = install_resource_to_user(self.user, file_contents=file_contents) self.assertTrue(added) resource_pk = resource.pk xhtml_pk = resource.widget.pk # Cache widget code response = client.get(reverse('wirecloud.widget_code_entry', kwargs=widget_id)) self.assertEqual(response.status_code, 200) old_code = response.content resource.delete() self.assertRaises(XHTML.DoesNotExist, XHTML.objects.get, pk=xhtml_pk) self.assertRaises(Widget.DoesNotExist, Widget.objects.get, resource__pk=resource_pk) self.assertRaises(CatalogueResource.DoesNotExist, CatalogueResource.objects.get, pk=resource_pk) # Use a different xhtml code file_contents = self.build_simple_wgt('template1.xml', b'code', other_files=('images/catalogue.png', 'images/catalogue_iphone.png', 'doc/index.html')) resource = install_resource_to_user(self.user, file_contents=file_contents) response = client.get(reverse('wirecloud.widget_code_entry', kwargs=widget_id)) self.assertEqual(response.status_code, 200) new_code = response.content self.assertNotEqual(old_code, new_code)
class PasswordResetChangeTest(ShadowConTestCase): def setUp(self): self.client = Client() def run_test(self, key): response = self.client.get(reverse(key)) self.assertSectionContains(response, "ShadowCon 2016", "title") return response def test_login(self): response = self.run_test('login') self.assertSectionContains(response, '<p><a href="%s">%s</a></p>' % (reverse('password_reset'), 'Lost password\\?'), 'section id="main" role="main"', '/section') self.assertSectionContains(response, '<p><a href="%s">%s</a></p>' % (reverse('convention:new_user'), 'Create New Account'), 'section id="main" role="main"', '/section') def test_logout(self): response = self.run_test('logout') self.assertSectionContains(response, 'You have successfully logged out', 'section id="main" role="main"', '/section') def test_password_change(self): self.client.login(username="******", password="******") response = self.run_test('password_change') self.assertSectionContains(response, 'Enter new password', 'section id="main" role="main"', '/section') def test_password_change_done(self): self.client.login(username="******", password="******") response = self.run_test('password_change_done') self.assertSectionContains(response, '<h2>Password Changed</h2>', 'section id="main" role="main"', '/section') def test_password_reset(self): response = self.run_test('password_reset') self.assertSectionContains(response, 'Forgotten your password\\? Enter your', 'section id="main" role="main"', '/section') def test_password_reset_done(self): response = self.run_test('password_reset_done') self.assertSectionContains(response, 'Password reset sent', 'section id="main" role="main"', '/section') def test_password_reset_confirm_invalid_link(self): response = self.client.get(reverse('password_reset_confirm', args=["invalid", "4a8-cd1bf13135ee4cae7176"])) self.assertSectionContains(response, "ShadowCon 2016", "title") self.assertSectionContains(response, 'The password reset link was invalid', 'section id="main" role="main"', '/section') def test_password_reset_confirm_valid_link(self): self.client.post(reverse('password_reset'), {"email": "*****@*****.**"}) email = self.get_email() start = str(email.body).index('/reset') stop = str(email.body).index('Your username, in case you\'ve forgotten: user') link = str(email.body)[start:stop].strip() response = self.client.get(link) self.assertSectionContains(response, "ShadowCon 2016", "title") self.assertSectionContains(response, 'Please enter your new password twice', 'section id="main" role="main"', '/section')
class GroupsTest(TestCase): multi_db = True fixtures = ['radcheck-test.json', 'radusergroup-test.json', 'radgroupcheck-test.json', 'auth-test.json'] def setUp(self): self.client = Client() def test_not_login(self): resp = self.client.get('/radmin/groups/') self.assertEqual(resp.status_code, 302) def test_groups(self): self.client.login(username='******', password='******') resp = self.client.get('/radmin/groups/') self.assertEqual(resp.status_code, 200) self.assertEqual(len(resp.context['groups']), 3) def test_group_detail(self): self.client.login(username='******', password='******') resp = self.client.post('/radmin/group/default/' , {'groupname' : 'default', 'simultaneous_use': u'4'}) self.assertEqual(resp.status_code, 302) self.assertEqual(resp['Location'], 'http://testserver/radmin/group/default/') resp = self.client.get('/radmin/group/default/') self.assertEqual(resp.status_code, 200) self.assertEqual(resp.context['form'].data, {'groupname': u'default', 'simultaneous_use': u'4'})
def test_ajax_urls(self): """ Tests ajax url to check on item favorited stats. Checks is_favorited, add, remove. """ # first create a sample item to be favorited favitem = FavoriteItem(name="Product 1") favitem.save() ctype = ContentType.objects.get_for_model(type(favitem)).pk client = Client() client.login(username=self.user.username, password="******") response = client.get(reverse("in_favs", kwargs={"content_type": ctype, "object_id": favitem.pk})) response_data = simplejson.loads(response.content) termprint("WARNING", response.content) self.assertFalse(response_data.get("in_favorites")) # add in a favorite fav = Favorites.objects.add_favorite(self.user, favitem) fav_len = len(Favorites.objects.all()) # check again - should return true response = client.get( reverse("in_favs", kwargs={"content_type": ctype, "object_id": favitem.pk}), {}, **{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"} ) response_data = simplejson.loads(response.content) termprint("INFO", response.content) self.assertTrue(response_data.get("in_favorites"))
def test_edit_item(self): timestamp = datetime.now() description = 'Coke' caffeine = 50 c = Client() c.login(username='******', password='******') response = c.post('/record/item', { 'time': self.timestamp, 'description': self.description, 'caffeine': self.caffeine, }) response = c.post('/edit/item?id=1', { 'time': timestamp, 'description': description, 'caffeine': caffeine, }) self.assertEqual(response.status_code, 303) record = Record.objects.get(pk=1) self.assertEqual(record.time, timestamp) self.assertEqual(record.caffeine, caffeine) self.assertEqual(record.description, description) response = c.post('/edit/item?id=2', { 'time': timestamp, 'description': description, 'caffeine': caffeine, }) self.assertEqual(response.status_code, 404)
def test_new_character_created(self): """ Test that new character gets created. """ csrf_client = Client(enforce_csrf_checks=True) try: csrf_client.force_login(self.test_user) except AttributeError: # For Django 1.8 csrf_client.login(username="******", password="******") response = csrf_client.get(reverse('new_character')) csrf_token = csrf_client.cookies['csrftoken'].value response = csrf_client.post(reverse('new_character'), {'character_name': ['Hrothgar'], 'alignment': ['CG'], 'strength-value': [9], 'dexterity-value': [9], 'constitution-value': [9], 'intelligence-value': [9], 'wisdom-value': [9], 'charisma-value': [9], 'csrfmiddlewaretoken': csrf_token}) self.assertIsInstance(response, HttpResponseRedirect) character = Character.objects.get(character_name="Hrothgar") self.assertEqual(AbilityScores.objects.filter( character=character).count(), 6) response = csrf_client.get(response.url).render() self.assertEqual(response.status_code, 200) self.assertContains(response, 'Hrothgar') self.assertNotContains(response, escape("['Hrothgar']")) self.assertContains(response, AbilityScores.ability_score_mod(9))
class DailyEventViewTest(TestCase): def setUp(self): self.client = Client() self.user = PyDayUser.objects._create_user("*****@*****.**", "secret", "MynameisWhat", "MynameisWho") self.client.login(email='*****@*****.**', password='******') def test_get_wrong_date(self): with self.assertTemplateUsed("error.html"): response = self.client.get('/calendar/daily_events/6000/60/60') self.assertContains(response, 'Impossible date') def test_get_right_date(self): with self.assertTemplateUsed('daily_event.html'): response = self.client.get('/calendar/daily_events/6000/10/10') self.assertEqual(response.status_code, 200) def test_no_date(self): date = datetime.now() with self.assertTemplateUsed('daily_event.html'): response = self.client.get(reverse("pyday_calendar:daily_events")) self.assertEqual(response.status_code, 200) self.assertContains(response, "Events for {} ".format(date.day))
class FlatpageCSRFTests(TestCase): fixtures = ['sample_flatpages'] urls = 'django.contrib.flatpages.tests.urls' def setUp(self): self.client = Client(enforce_csrf_checks=True) self.old_MIDDLEWARE_CLASSES = settings.MIDDLEWARE_CLASSES flatpage_middleware_class = 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware' csrf_middleware_class = 'django.middleware.csrf.CsrfViewMiddleware' if csrf_middleware_class not in settings.MIDDLEWARE_CLASSES: settings.MIDDLEWARE_CLASSES += (csrf_middleware_class, ) if flatpage_middleware_class not in settings.MIDDLEWARE_CLASSES: settings.MIDDLEWARE_CLASSES += (flatpage_middleware_class, ) self.old_TEMPLATE_DIRS = settings.TEMPLATE_DIRS settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), 'templates'), ) self.old_LOGIN_URL = settings.LOGIN_URL settings.LOGIN_URL = '/accounts/login/' def tearDown(self): settings.MIDDLEWARE_CLASSES = self.old_MIDDLEWARE_CLASSES settings.TEMPLATE_DIRS = self.old_TEMPLATE_DIRS settings.LOGIN_URL = self.old_LOGIN_URL def test_view_flatpage(self): "A flatpage can be served through a view, even when the middleware is in use" response = self.client.get('/flatpage_root/flatpage/') self.assertEquals(response.status_code, 200) self.assertContains(response, "<p>Isn't it flat!</p>") def test_view_non_existent_flatpage(self): "A non-existent flatpage raises 404 when served through a view, even when the middleware is in use" response = self.client.get('/flatpage_root/no_such_flatpage/') self.assertEquals(response.status_code, 404) def test_view_authenticated_flatpage(self): "A flatpage served through a view can require authentication" response = self.client.get('/flatpage_root/sekrit/') self.assertRedirects(response, '/accounts/login/?next=/flatpage_root/sekrit/') User.objects.create_user('testuser', '*****@*****.**', 's3krit') self.client.login(username='******', password='******') response = self.client.get('/flatpage_root/sekrit/') self.assertEquals(response.status_code, 200) self.assertContains(response, "<p>Isn't it sekrit!</p>") def test_fallback_flatpage(self): "A flatpage can be served by the fallback middlware" response = self.client.get('/flatpage/') self.assertEquals(response.status_code, 200) self.assertContains(response, "<p>Isn't it flat!</p>") def test_fallback_non_existent_flatpage(self): "A non-existent flatpage raises a 404 when served by the fallback middlware" response = self.client.get('/no_such_flatpage/') self.assertEquals(response.status_code, 404) def test_post_view_flatpage(self): "POSTing to a flatpage served through a view will raise a CSRF error if no token is provided (Refs #14156)" response = self.client.post('/flatpage_root/flatpage/') self.assertEquals(response.status_code, 403) def test_post_fallback_flatpage(self): "POSTing to a flatpage served by the middleware will raise a CSRF error if no token is provided (Refs #14156)" response = self.client.post('/flatpage/') self.assertEquals(response.status_code, 403) def test_post_unknown_page(self): "POSTing to an unknown page isn't caught as a 403 CSRF error" response = self.client.post('/no_such_page/') self.assertEquals(response.status_code, 404)
class AccountTest(TestCase): def setUp(self): self.client = Client() self.factory = RequestFactory() def test_validate_account(self): site = get_current_site().domain user = BlogUser.objects.create_superuser(email="*****@*****.**", username="******", password="******") testuser = BlogUser.objects.get(username='******') loginresult = self.client.login(username='******', password='******') self.assertEqual(loginresult, True) response = self.client.get('/admin/') self.assertEqual(response.status_code, 200) category = Category() category.name = "categoryaaa" category.created_time = datetime.datetime.now() category.last_mod_time = datetime.datetime.now() category.save() article = Article() article.title = "nicetitleaaa" article.body = "nicecontentaaa" article.author = user article.category = category article.type = 'a' article.status = 'p' article.save() response = self.client.get(article.get_admin_url()) self.assertEqual(response.status_code, 200) def test_validate_register(self): self.assertEquals( 0, len(BlogUser.objects.filter(email='*****@*****.**'))) response = self.client.post( reverse('account:register'), { 'username': '******', 'email': '*****@*****.**', 'password1': 'password123!q@wE#R$T', 'password2': 'password123!q@wE#R$T', }) self.assertEquals( 1, len(BlogUser.objects.filter(email='*****@*****.**'))) self.client.login(username='******', password='******') user = BlogUser.objects.filter(email='*****@*****.**')[0] user.is_superuser = True user.is_staff = True user.save() delete_view_cache(user.username) category = Category() category.name = "categoryaaa" category.created_time = datetime.datetime.now() category.last_mod_time = datetime.datetime.now() category.save() article = Article() article.category = category article.title = "nicetitle333" article.body = "nicecontentttt" article.author = user article.type = 'a' article.status = 'p' article.save() response = self.client.get(article.get_admin_url()) self.assertEqual(response.status_code, 200) response = self.client.get(reverse('account:logout')) self.assertIn(response.status_code, [301, 302, 200]) response = self.client.get(article.get_admin_url()) self.assertIn(response.status_code, [301, 302, 200]) response = self.client.post(reverse('account:login'), { 'username': '******', 'password': '******' }) self.assertIn(response.status_code, [301, 302, 200]) response = self.client.get(article.get_admin_url()) self.assertIn(response.status_code, [301, 302, 200])
class EditProjectTestCase(TestCase): def setUp(self): # create needed objects self.user1 = create_user("test1", "*****@*****.**", "test1") self.user2 = create_user("test2", "*****@*****.**", "test2") self.user3 = create_user("test3", "*****@*****.**", "test3") self.course1 = create_course("course1", "slug1", self.user1) self.enrollment1 = create_course_enrollment(self.user1, self.course1, "student") self.enrollment2 = create_course_enrollment(self.user2, self.course1, "student") self.project1 = create_project(self.user1, self.user1, self.user1, self.course1, "slug1") self.membership1 = create_project_membership(self.user1, self.project1, "invite reason") self.client = Client() # TODO: def tearDown(self): pass # TODO: def test_add_member(self): """ - Successfully add a member """ # self.client.login(username='******', password='******') # response = self.client.get('/project/slug1/add/test2') # print("status code: ", response.status_code) # print("all projects", Project.objects.all()) # self.assertTrue(response.status_code == '200') pass def test_try_add_member_success(self): """ - Successfully adding a member that meets validation to be able to join """ self.client.login(username='******', password='******') response = self.client.post('/project/slug1/tryadd/test2') # Assert redirect was returned self.assertTrue(response.status_code == 302) # Assert project now has 1 member self.assertTrue(self.user2 in self.project1.members.all()) def test_try_add_member_fail(self): """ - Tests not accepting a member if they are not in the course or already a member - Tests project is not accepting members """ self.client.login(username='******', password='******') response = self.client.post('/project/slug1/tryadd/test3') # Assert redirect was returned self.assertTrue(response.status_code == 302) # Assert user3 was not successfully added (user3 is not enrolled in course1) self.assertTrue(self.user3 not in self.project1.members.all()) # Test project is not accepting members and a member is added self.project1.avail_mem = False self.project1.save() response = self.client.post('/project/slug1/tryadd/test2') self.assertTrue(self.user2 not in self.project1.members.all())
class FarmTemplateTests(TestCase): def setUp(self): self.client = Client() self.user_a = get_user_model().objects.create_user( email="*****@*****.**", password="******", ) self.user_b = get_user_model().objects.create_user( email="*****@*****.**", password="******", ) # Disable HTTP request warnings logging.disable() def tearDown(self): # Reenable HTTP request warnings logging.disable(logging.NOTSET) def test_create_farm(self): """Test creating a farm""" # Check required authentication response = self.client.get(reverse("farm-setup")) self.assertRedirects( response, reverse("login") + "?next=" + reverse("farm-setup")) response = self.client.post(reverse("farm-setup")) self.assertRedirects( response, reverse("login") + "?next=" + reverse("farm-setup")) with self.settings( STATICFILES_STORAGE= "django.contrib.staticfiles.storage.StaticFilesStorage"): self.client.login(username=self.user_a.email, password="******") response = self.client.get(reverse("farm-setup")) self.assertContains(response, "Name") self.assertContains(response, "Address") # Check poorly formatted requests data = {} response = self.client.post(reverse("farm-setup"), data) self.assertContains(response, "Farm Setup", status_code=400) data = {"name": "test farm"} response = self.client.post(reverse("farm-setup"), data) self.assertContains(response, "Farm Setup", status_code=400) data = {"address": "some place"} response = self.client.post(reverse("farm-setup"), data) self.assertContains(response, "Farm Setup", status_code=400) self.assertFalse(Farm.objects.all()) # Check valid requests data = {"name": "good farm", "address": "some place"} response = self.client.post(reverse("farm-setup"), data) self.assertRedirects(response, reverse("farm-list")) self.assertTrue(Farm.objects.all()) farm = Farm.objects.get(name=data["name"]) self.assertEqual(farm.name, data["name"]) self.assertEqual(farm.owner, self.user_a) def test_farm_list(self): """Test showing all farms registered to a user""" farm_address_a = Address.objects.create( raw="Some Street 42, Any Town, Major City, New Country", ) farm_coordinator_a = Coordinator.objects.create( local_ip_address="192.168.0.1", external_ip_address="1.1.1.1") farm_a = Farm.objects.create(name="Farm A", address=farm_address_a, coordinator=farm_coordinator_a) farm_b = Farm.objects.create(name="Farm B") # Test required authentication response = self.client.get(reverse("farm-list")) self.assertRedirects( response, reverse("login") + "?next=" + reverse("farm-list")) # Test no owned farms self.client.login(username=self.user_a.email, password="******") response = self.client.get(reverse("farm-list")) self.assertContains(response, "Farms") self.assertContains(response, "No farms found") # Test one ownder farm farm_a.owner = self.user_a farm_a.save() farm_b.owner = self.user_b farm_b.save() response = self.client.get(reverse("farm-list")) self.assertContains(response, farm_a.name) self.assertNotContains(response, farm_b.name) self.assertContains(response, farm_address_a.raw)
class CoordinatorSetupTests(TestCase): def setUp(self): self.client = Client() self.user_a = get_user_model().objects.create_user( email="*****@*****.**", password="******", ) # Disable HTTP request warnings logging.disable() def tearDown(self): # Reenable HTTP request warnings logging.disable(logging.NOTSET) def test_coordinator_selection(self): """Test that pinging coordinators can be found""" # Test login required response = self.client.get(reverse("coordinator-setup-select"), REMOTE_ADDR="127.0.0.1") self.assertRedirects( response, reverse("login") + "?next=" + reverse("coordinator-setup-select")) # Test with authenticated user for remaining asserts self.client.login(username=self.user_a.email, password="******") # Test internal IP address response = self.client.get(reverse("coordinator-setup-select"), REMOTE_ADDR="127.0.0.1") self.assertContains( response, "external IP address can not be used for a lookup") self.assertContains(response, "127.0.0.1") # Test empty setup page response = self.client.get(reverse("coordinator-setup-select"), REMOTE_ADDR="1.1.1.1") self.assertContains(response, "no coordinators were found") # Test only registered coordinators farm_a_1 = Farm.objects.create(name="TestFarm_A_1") farm_a_2 = Farm.objects.create(name="TestFarm_A_2") coordinator_a_1 = Coordinator.objects.create( local_ip_address="192.168.0.1", external_ip_address="1.1.1.1", farm=farm_a_1) coordinator_a_2 = Coordinator.objects.create( local_ip_address="192.168.0.1", external_ip_address="1.1.1.1", farm=farm_a_2) response = self.client.get(reverse("coordinator-setup-select"), REMOTE_ADDR="1.1.1.1") self.assertContains(response, coordinator_a_1.farm.name) self.assertContains(response, coordinator_a_2.farm.name) self.assertContains(response, "None found") # Test listing unregistered coordinators coordinator_b_1 = Coordinator.objects.create( local_ip_address="192.168.0.1", external_ip_address="1.1.1.1") coordinator_b_2 = Coordinator.objects.create( local_ip_address="192.168.0.1", external_ip_address="1.1.1.1") response = self.client.get(reverse("coordinator-setup-select"), REMOTE_ADDR="1.1.1.1") self.assertContains(response, coordinator_b_1.id.hex[:7]) self.assertContains(response, coordinator_b_2.id.hex[:7]) # Test not showing coordinators for a user from a different subnet response = self.client.get(reverse("coordinator-setup-select"), REMOTE_ADDR="1.1.1.2") self.assertContains(response, "no coordinators were found") def test_select_to_register(self): """Test that selecting a coordinator redirects to its registration""" # Test login required response = self.client.post(reverse("coordinator-setup-select"), REMOTE_ADDR="127.0.0.1") self.assertRedirects( response, reverse("login") + "?next=" + reverse("coordinator-setup-select")) # Test with a logged in user and valid coordinator for the remaining asserts self.client.login(username=self.user_a.email, password="******") coordinator_a_1 = Coordinator.objects.create( local_ip_address="192.168.0.1", external_ip_address="1.1.1.1") # Test blank post request data = {} response = self.client.post(reverse("coordinator-setup-select"), data) self.assertContains(response, "This field is required", status_code=400) # Test invalid UUID data = {"coordinator_id": coordinator_a_1.id.hex[:-1]} # import ipdb; ipdb.set_trace() response = self.client.post(reverse("coordinator-setup-select"), data) self.assertContains(response, "Enter a valid UUID", status_code=400) # Test a valid request data = {"coordinator_id": coordinator_a_1.id} response = self.client.post(reverse("coordinator-setup-select"), data) self.assertRedirects( response, reverse("coordinator-setup-register", kwargs={ "pk": coordinator_a_1.id, }), ) def test_register_coordinator(self): """Test registering a coordinator""" # Test login required coordinator_a = Coordinator.objects.create( local_ip_address="192.168.0.1", external_ip_address="1.1.1.1") response = self.client.get( reverse("coordinator-setup-register", kwargs={"pk": coordinator_a.id}), REMOTE_ADDR="127.0.0.1", ) self.assertRedirects( response, reverse("login") + "?next=" + reverse( "coordinator-setup-register", kwargs={"pk": coordinator_a.id}), ) # Test if the form fields were loaded response = self.client.get( reverse("coordinator-setup-register", kwargs={"pk": coordinator_a.id}), REMOTE_ADDR="127.0.0.1", ) def test_coordinator_form(self): farm = Farm.objects.create(name="TestFarm") farms = Farm.objects.all() # Test a valid form data = {"subdomain_prefix": "valid-name", "farm": farm.id} form = CoordinatorSetupRegistrationForm(farms=farms, data=data) self.assertTrue(form.is_valid()) # Test lowercasing data = {"subdomain_prefix": "Val1D-Name", "farm": farm.id} form = CoordinatorSetupRegistrationForm(farms=farms, data=data) self.assertTrue(form.is_valid()) self.assertEqual(form.cleaned_data["subdomain_prefix"], data["subdomain_prefix"].lower()) # Test underscores data = {"subdomain_prefix": "inVal1D_Name", "farm": farm.id} form = CoordinatorSetupRegistrationForm(farms=farms, data=data) self.assertFalse(form.is_valid()) # Test dots data = {"subdomain_prefix": "inVal1D.Name", "farm": farm.id} form = CoordinatorSetupRegistrationForm(farms=farms, data=data) self.assertFalse(form.is_valid()) # Test leading hyphen data = {"subdomain_prefix": "-inVal1DName", "farm": farm.id} form = CoordinatorSetupRegistrationForm(farms=farms, data=data) self.assertFalse(form.is_valid()) # Test other characters data = {"subdomain_prefix": "a*ä", "farm": farm.id} form = CoordinatorSetupRegistrationForm(farms=farms, data=data) self.assertFalse(form.is_valid())
class GraphManagerViewTests(ArchesTestCase): @classmethod def setUpClass(cls): cls.loadOntology() def setUp(self): self.NODE_NODETYPE_GRAPHID = '22000000-0000-0000-0000-000000000001' if len(Graph.objects.filter(graphid=self.NODE_NODETYPE_GRAPHID)) == 0: # Node Branch graph_dict = { "author": "Arches", "color": None, "deploymentdate": None, "deploymentfile": None, "description": "Represents a single node in a graph", "graphid": "22000000-0000-0000-0000-000000000000", "iconclass": "fa fa-circle", "isactive": True, "isresource": False, "name": "Node", "ontology_id": "e6e8db47-2ccf-11e6-927e-b8f6b115d7dd", "subtitle": "Represents a single node in a graph.", "version": "v1" } GraphModel.objects.create(**graph_dict).save() node_dict = { "config": None, "datatype": "semantic", "description": "Represents a single node in a graph", "graph_id": "22000000-0000-0000-0000-000000000000", "isrequired": False, "issearchable": True, "istopnode": True, "name": "Node", "nodegroup_id": None, "nodeid": "20000000-0000-0000-0000-100000000000", "ontologyclass": "http://www.cidoc-crm.org/cidoc-crm/E1_CRM_Entity", } Node.objects.create(**node_dict).save() # Node/Node Type Branch graph_dict = { "author": "Arches", "color": None, "deploymentdate": None, "deploymentfile": None, "description": "Represents a node and node type pairing", "graphid": "22000000-0000-0000-0000-000000000001", "iconclass": "fa fa-angle-double-down", "isactive": True, "isresource": False, "name": "Node/Node Type", "ontology_id": "e6e8db47-2ccf-11e6-927e-b8f6b115d7dd", "subtitle": "Represents a node and node type pairing", "version": "v1" } GraphModel.objects.create(**graph_dict).save() nodegroup_dict = { "cardinality": "n", "legacygroupid": "", "nodegroupid": "20000000-0000-0000-0000-100000000001", "parentnodegroup_id": None } NodeGroup.objects.create(**nodegroup_dict).save() card_dict = { "active": True, "cardid": "bf9ea150-3eaa-11e8-8b2b-c3a348661f61", "description": "Represents a node and node type pairing", "graph_id": "22000000-0000-0000-0000-000000000001", "helpenabled": False, "helptext": None, "helptitle": None, "instructions": "", "name": "Node/Node Type", "nodegroup_id": "20000000-0000-0000-0000-100000000001", "sortorder": None, "visible": True } CardModel.objects.create(**card_dict).save() nodes = [{ "config": None, "datatype": "string", "description": "", "graph_id": "22000000-0000-0000-0000-000000000001", "isrequired": False, "issearchable": True, "istopnode": True, "name": "Node", "nodegroup_id": "20000000-0000-0000-0000-100000000001", "nodeid": "20000000-0000-0000-0000-100000000001", "ontologyclass": "http://www.cidoc-crm.org/cidoc-crm/E1_CRM_Entity" }, { "config": { "rdmCollection": None }, "datatype": "concept", "description": "", "graph_id": "22000000-0000-0000-0000-000000000001", "isrequired": False, "issearchable": True, "istopnode": False, "name": "Node Type", "nodegroup_id": "20000000-0000-0000-0000-100000000001", "nodeid": "20000000-0000-0000-0000-100000000002", "ontologyclass": "http://www.cidoc-crm.org/cidoc-crm/E55_Type" }] for node in nodes: Node.objects.create(**node).save() edges_dict = { "description": None, "domainnode_id": "20000000-0000-0000-0000-100000000001", "edgeid": "22200000-0000-0000-0000-000000000001", "graph_id": "22000000-0000-0000-0000-000000000001", "name": None, "ontologyproperty": "http://www.cidoc-crm.org/cidoc-crm/P2_has_type", "rangenode_id": "20000000-0000-0000-0000-100000000002" } Edge.objects.create(**edges_dict).save() graph = Graph.new() graph.name = "TEST GRAPH" graph.subtitle = "ARCHES TEST GRAPH" graph.author = "Arches" graph.description = "ARCHES TEST GRAPH" graph.ontology_id = "e6e8db47-2ccf-11e6-927e-b8f6b115d7dd" graph.version = "v1.0.0" graph.isactive = False graph.iconclass = "fa fa-building" graph.nodegroups = [] graph.save() graph.root.name = 'ROOT NODE' graph.root.description = 'Test Root Node' graph.root.ontologyclass = 'http://www.cidoc-crm.org/cidoc-crm/E1_CRM_Entity' graph.root.datatype = 'semantic' graph.root.save() graph = Graph.objects.get(graphid=graph.pk) self.appended_branch_1 = graph.append_branch( 'http://www.ics.forth.gr/isl/CRMdig/L54_is_same-as', graphid=self.NODE_NODETYPE_GRAPHID) self.appended_branch_2 = graph.append_branch( 'http://www.ics.forth.gr/isl/CRMdig/L54_is_same-as', graphid=self.NODE_NODETYPE_GRAPHID) graph.save() self.ROOT_ID = graph.root.nodeid self.GRAPH_ID = str(graph.pk) self.NODE_COUNT = 5 self.client = Client() def tearDown(self): try: self.deleteGraph(self.GRAPH_ID) except: pass def test_graph_manager(self): """ Test the graph manager view """ self.client.login(username='******', password='******') url = reverse('graph', kwargs={'graphid': ''}) response = self.client.get(url) graphs = json.loads(response.context['graphs']) self.assertEqual( len(graphs), GraphModel.objects.all().exclude( graphid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID).count()) url = reverse('graph_designer', kwargs={'graphid': self.GRAPH_ID}) response = self.client.get(url) graph = json.loads(response.context['graph_json']) node_count = len(graph['nodes']) self.assertEqual(node_count, self.NODE_COUNT) edge_count = len(graph['edges']) self.assertEqual(edge_count, self.NODE_COUNT - 1) def test_graph_settings(self): """ Test the graph settings view """ self.client.login(username='******', password='******') url = reverse('graph_settings', kwargs={'graphid': self.GRAPH_ID}) response = self.client.get(url) self.assertEqual(response.status_code, 200) graph = json.loads(response.content) graph['name'] = 'new graph name' post_data = { 'graph': graph, 'relatable_resource_ids': [str(self.ROOT_ID)] } post_data = JSONSerializer().serialize(post_data) content_type = 'application/x-www-form-urlencoded' response = self.client.post(url, post_data, content_type) response_json = json.loads(response.content) self.assertTrue(response_json['success']) self.assertEqual(response_json['graph']['name'], 'new graph name') self.assertTrue( str(self.ROOT_ID) in response_json['relatable_resource_ids']) def test_node_update(self): """ Test updating a node (HERITAGE_RESOURCE_PLACE) via node view """ self.client.login(username='******', password='******') url = reverse('update_node', kwargs={'graphid': self.GRAPH_ID}) node = Node.objects.get(nodeid=str(self.appended_branch_1.root.pk)) node.name = "new node name" nodegroup, created = NodeGroup.objects.get_or_create( pk=str(self.appended_branch_1.root.pk)) node.nodegroup = nodegroup post_data = JSONSerializer().serializeToPython(node) post_data[ "parentproperty"] = "http://www.ics.forth.gr/isl/CRMdig/L54_is_same-as" content_type = 'application/x-www-form-urlencoded' response = self.client.post(url, JSONSerializer().serialize(post_data), content_type) response_json = json.loads(response.content) node_count = 0 for node in response_json['nodes']: if node['nodeid'] == str(self.appended_branch_1.root.pk): self.assertEqual(node['name'], 'new node name') if node['nodegroup_id'] == str(self.appended_branch_1.root.pk): node_count = node_count + 1 self.assertEqual(node_count, 2) node_ = Node.objects.get(nodeid=str(self.appended_branch_1.root.pk)) self.assertEqual(node_.name, 'new node name') self.assertTrue(node_.is_collector) def test_node_delete(self): """ Test delete a node (HERITAGE_RESOURCE_PLACE) via node view """ self.client.login(username='******', password='******') node = Node.objects.get(nodeid=str(self.appended_branch_1.root.pk)) url = reverse('delete_node', kwargs={'graphid': self.GRAPH_ID}) post_data = JSONSerializer().serialize({'nodeid': node.nodeid}) response = self.client.delete(url, post_data) self.assertEqual(response.status_code, 200) graph = Graph.objects.get(graphid=self.GRAPH_ID).serialize() self.assertEqual(len(graph['nodes']), 3) self.assertEqual(len(graph['edges']), 2) def test_graph_clone(self): """ Test clone a graph (HERITAGE_RESOURCE) via view """ self.client.login(username='******', password='******') url = reverse('clone_graph', kwargs={'graphid': self.GRAPH_ID}) post_data = {} content_type = 'application/x-www-form-urlencoded' response = self.client.post(url, post_data, content_type) response_json = json.loads(response.content) self.assertEqual(len(response_json['nodes']), self.NODE_COUNT) def test_new_graph(self): """ Test creating a new graph via the view """ self.client.login(username='******', password='******') url = reverse('new_graph') post_data = JSONSerializer().serialize({'isresource': False}) content_type = 'application/x-www-form-urlencoded' response = self.client.post(url, post_data, content_type) response_json = json.loads(response.content) self.assertEqual(len(response_json['nodes']), 1) self.assertFalse(response_json['isresource']) def test_delete_graph(self): """ test the graph delete method """ self.client.login(username='******', password='******') url = reverse('delete_graph', kwargs={'graphid': self.GRAPH_ID}) response = self.client.delete(url) node_count = Node.objects.filter(graph_id=self.GRAPH_ID).count() edge_count = Edge.objects.filter(graph_id=self.GRAPH_ID).count() self.assertEqual(node_count, 0) self.assertEqual(edge_count, 0) def test_graph_export(self): """ test graph export method """ self.client.login(username='******', password='******') url = reverse('export_graph', kwargs={'graphid': self.GRAPH_ID}) response = self.client.get(url) graph_json = json.loads(response._container[0]) node_count = len(graph_json['graph'][0]['nodes']) self.assertTrue(response._container[0]) self.assertEqual(node_count, self.NODE_COUNT) self.assertEqual( list(response._headers['content-type'])[1], 'json/plain') def test_graph_import(self): """ test graph import method """ self.client.login(username='******', password='******') url = reverse('import_graph') with open( os.path.join( list(test_settings.RESOURCE_GRAPH_LOCATIONS)[0], 'Cardinality Test Model.json')) as f: response = self.client.post(url, {'importedGraph': f}) self.assertIsNotNone(response.content) # Note: If you change the imported_json array to make this test work you should also change the expected # response in the import_graph method in arches.app.media.js.views.graph.js imported_json = JSONDeserializer().deserialize(response.content) self.assertEqual(imported_json[0], []) self.assertEqual(imported_json[1]['graphs_saved'], 1) self.assertEqual(imported_json[1]['name'], 'Cardinality Test Model')
class ReportsTestCase(TestCase): def setUp(self): call_command('migrate', verbosity=0) self.c = HttpClient() fake_user = fake.simple_profile() fake_password = fake.password() user = User.objects.create_user(fake_user['username'], fake_user['mail'], fake_password) site_permission = SitePermission.objects.create(user=user) site_permission.sites.set(Site.objects.filter(id=1)) site_permission.save() self.c.login(username=fake_user['username'], password=fake_password) call_command('fake', verbosity=0, iterations=1) def assert_entries_by_params(self, params): url = '/reports/export/?' for param, value in params.items(): url += '{0}={1}&'.format(param, value) report = self.c.get(url) lines = DictReader(StringIO(report.content.decode('utf-8'))) for line in lines: self.filter_exported_entry(line).delete() self.assertFalse(Entry.objects.filter(**params).exists()) def filter_exported_entry(self, line): # TODO: Improve this for better reporting when assertions fail. entries = Entry.objects.filter(date=line['date'], duration=parse_duration( line['duration']), note=line['note'], project__name=line['project__name'], user__username=line['user__username']) self.assertEqual(len(entries), 1) return entries[0] def test_export_response(self): report = self.c.get('/reports/export/') self.assertEqual(report.status_code, 200) self.assertEqual(report.get('Content-Type'), 'text/csv') self.assertEqual(report.get('Content-Disposition'), 'attachment; filename="report.csv"') def test_export_all(self): report = self.c.get('/reports/export/') lines = DictReader(StringIO(report.content.decode('utf-8'))) for line in lines: self.filter_exported_entry(line).delete() # The above should have deleted _all_ entries self.assertFalse(Entry.objects.all().exists()) def test_export_formats(self): for f in ['csv', 'xls', 'xlsx', 'tsv', 'ods', 'json', 'yaml', 'html']: report = self.c.get('/reports/export/?export_format={0}'.format(f)) self.assertEqual(report.status_code, 200) self.assertEqual(report.get('Content-Type'), 'text/{0}'.format(f)) def test_export_param_project(self): self.assert_entries_by_params({'project': Project.objects.first().id}) def test_export_param_client(self): self.assert_entries_by_params( {'project__client': Client.objects.first().id}) def test_export_param_user(self): self.assert_entries_by_params({'user': User.objects.first().id}) def test_export_param_date_range(self): dates = sorted([Entry.objects.first().date, Entry.objects.last().date]) self.assert_entries_by_params({ 'date__gte': str(dates[0]), 'date__lte': str(dates[1]) })
def handle(self, *args, **options): root = User( username='******', email='*****@*****.**', first_name='demo root firstname', last_name='demo root lastname', is_active=True, is_superuser=True, is_staff=True, phone='0917823099', birthday='2016-01-01', is_editor=True, is_guest=True, is_manager=True, is_advanced_editor=True, is_license=True, is_book=True, auth_email=True, auth_phone=True, education=u'學士', ) root.set_password('root') root.status = root.STATUS['active'] root.save() org = Organization.objects.create(name=u'eDocumentService', address=u'台北市大同區1段149號7樓', email=u'*****@*****.**', phone='0917823098', manager=root, is_service_center=True) root.org = org root.save() client = Client() response = client.post( reverse('register'), { 'username': '******', 'password': '******', 'confirm_password': '******', 'email': '*****@*****.**', 'first_name': 'demo editor firstname', 'last_name': 'demo editor lastname', 'phone': '1234567890', 'birthday': '2016-01-01', 'education': u'碩士', 'role': 'Editor', 'is_book': 'on', 'org': u'1', 'professional_field': u'資訊工程學', 'is_privacy': True }) client = Client() response = client.post( reverse( 'genericUser:review_user', kwargs={ 'username': '******', }, ), { 'active': 'on', 'editor': 'on', # 'guest': 'on', 'review': 'success', 'reason': '', }, ) editor = User.objects.get(username='******') editor.auth_email = True editor.auth_phone = True editor.save() assert editor.is_active == True, 'is_active False' assert editor.is_editor == True, 'is_editor False' assert editor.is_license == True, 'is_license False' with open('temp/dcf.jpg') as dcf_file, open( 'temp/dcb.jpg') as dcb_file: response = client.post( reverse('register'), { 'username': '******', 'password': '******', 'confirm_password': '******', 'email': '*****@*****.**', 'first_name': 'demo guest firstname', 'last_name': 'demo guest lastname', 'phone': '1234567899', 'birthday': '2016-01-01', 'education': u'碩士', 'is_book': 'on', 'role': 'Guest', 'org': u'1', 'disability_card_front': dcf_file, 'disability_card_back': dcb_file, 'is_privacy': True, }) response = client.post( reverse( 'genericUser:review_user', kwargs={ 'username': '******', }, ), { 'active': 'on', # 'editor': 'on', 'guest': 'on', 'review': 'success', 'reason': '', }, ) guest = User.objects.get(username='******') guest.auth_email = True guest.auth_phone = True guest.save() response = client.post( reverse('register'), { 'username': '******', 'password': '******', 'confirm_password': '******', 'email': '*****@*****.**', 'first_name': 'demo manager firstname', 'last_name': 'demo manager lastname', 'phone': '1234567898', 'birthday': '2016-01-01', 'education': u'碩士', 'is_book': 'on', 'org': u'1', 'role': 'Editor', 'professional_field': u'資訊工程學', 'is_privacy': True, }, ) response = client.post( reverse( 'genericUser:review_user', kwargs={ 'username': '******', }, ), { 'active': 'on', 'editor': 'on', 'manager': 'on', 'review': 'success', 'reason': '', }, ) manager = User.objects.get(username='******') manager.auth_email = True manager.auth_phone = True manager.save() src = BASE_DIR + u'/temp/藍色駭客.zip' with open(src) as book_file: client = Client() client.login(username='******', password='******') response = client.post( reverse('ebookSystem:book_create'), { u'ISBN': u'9789573321569', u'author': u'傑佛瑞.迪佛(Jeffery Deaver)著; 宋瑛堂譯', u'house': u'皇冠', u'bookname': u'藍色駭客', u'date': u'2005-07-01', u'bookbinding': '平裝', u'chinese_book_category': '874', u'order': '初版', 'fileObject': book_file, }, # HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) # print response.json()['message'] assert response.status_code == 302, 'status_code' + str( response.status_code) assert len(Book.objects.all()) == 1, 'create book fail' assert len(EBook.objects.all()) == 10, 'create part fail' book = Book.objects.get(ISBN='9789573321569') assert os.path.exists(book.path), 'book resource folder not exist' from zipfile import ZipFile src = BASE_DIR + '/temp/part.zip' dst = book.path + u'/OCR' with ZipFile(src, 'r') as partFile: partFile.extractall(dst) client = Client() client.login(username='******', password='******') response = client.post( reverse( 'ebookSystem:review_document', kwargs={ 'book_ISBN': '9789573321569', }, ), { 'review': 'success', 'reason': '', }, HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) ebook = EBook.objects.get(book=book, part=1) assert ebook.change_status( 1, 'edit', user=root, deadline='2017-12-31'), 'change status error' ebook.service_hours = 90 ebook.save() count = [0, 0, 1, 2, 3] for i in range(90): EditLog.objects.create( edit_record=EditRecord.objects.get( part=ebook, category='based', number_of_times=ebook.number_of_times), user=User.objects.get(username='******'), time=timezone.now(), order=i, edit_count=count[i % 5], ) assert ebook.change_status(1, 'review'), 'change status error' src = BASE_DIR + u'/temp/part1-finish-sp.txt' shutil.copy2(src, ebook.get_path('-finish')) client = Client() client.login(username='******', password='******') response = client.post( reverse( 'ebookSystem:review_part', kwargs={ 'ISBN_part': ebook.ISBN_part, }, ), { 'review': 'success', 'reason': '', }, HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) ebook = EBook.objects.get(book=book, part=2) assert ebook.change_status( 1, 'edit', user=root, deadline='2017-12-31'), 'change status error' ebook.service_hours = 80 count = [0, 0, 1, 2, 3] for i in range(80): EditLog.objects.create( edit_record=EditRecord.objects.get( part=ebook, category='based', number_of_times=ebook.number_of_times), user=User.objects.get(username='******'), time=timezone.now(), order=i, edit_count=count[i % 5], ) assert ebook.change_status(1, 'review'), 'change status error' src = BASE_DIR + u'/temp/part1-finish-sp.txt' shutil.copy2(src, ebook.get_path('-finish')) client = Client() client.login(username='******', password='******') response = client.post( reverse( 'ebookSystem:review_part', kwargs={ 'ISBN_part': ebook.ISBN_part, }, ), { 'review': 'success', 'reason': '', }, HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) src = BASE_DIR + u'/temp/山羊島的藍色奇蹟.zip' with open(src) as book_file: client = Client() client.login(username='******', password='******') response = client.post( reverse('ebookSystem:book_create'), { u'ISBN': u'9789866104626', u'author': u'多利安助川著; 卓惠娟譯', u'house': u'博識圖書', u'bookname': u'山羊島的藍色奇蹟', u'date': u'2015-07-01', u'bookbinding': '平裝', u'chinese_book_category': '861', u'order': '初版', 'fileObject': book_file, }, # HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) assert response.status_code == 302, 'status_code' + str( response.status_code) assert len(Book.objects.all()) == 2, 'create book fail' book = Book.objects.get(ISBN=u'9789866104626') assert os.path.exists(book.path), 'book resource folder not exist' assert len(EBook.objects.all()) == 16, 'create part fail' assert len(book.ebook_set.all()) == 6, 'create part fail' book_file = open(BASE_DIR + u'/temp/自創思維.epub') client = Client() client.login(username='******', password='******') response = client.post( reverse('ebookSystem:book_upload'), { u'ISBN': u'9789863981459', u'author': u'雷德.霍夫曼(Reid Hoffman), 班.卡斯諾查(Ben Casnocha)著; 洪慧芳譯', u'house': u'天下雜誌', u'bookname': u'自創思維: 人生是永遠的測試版,瞬息萬變世界的新工作態度', u'date': u'2016-02-01', u'bookbinding': '平裝', u'chinese_book_category': '494', u'order': '第二版', 'fileObject': book_file, 'category': 'epub', }, # HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) book_file.close() assert len(Book.objects.all()) == 3, 'create book fail' client = Client() client.login(username='******', password='******') previous_count = len(Announcement.objects.all()) response = client.post( reverse('genericUser:announcement_create'), { 'title': u'title', 'content': u'<p>content_p1</p><p>content_p2</p>', 'category': u'志工快訊', }, HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) assert len(Announcement.objects.all() ) == previous_count + 1, 'create announcement fail' GetBookRecord.objects.create(book=book, user=root, get_ip='192.168.1.0') GetBookRecord.objects.create(book=book, user=root, get_ip='192.168.1.0') QAndA.objects.create( question='<p>question 1</p>', answer='<p>answer 1</p>', ) QAndA.objects.create( question='<p>question 2</p>', answer='<p>answer 2</p>', ) client = Client() client.login(username='******', password='******') previous_count = len(LibraryRecord.objects.all()) response = client.post( reverse('ebookSystem:library_action'), { 'ISBN': '9789863981459', 'action': 'check_out', }, HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) assert len(LibraryRecord.objects.all() ) == previous_count + 1, 'create announcement fail'
class ImageTest(TestCase): def setUp(self): cache.clear() self.client = Client() user1 = { 'name': 'sarah', 'surname': 'oconnor', 'username': '******', 'email': '*****@*****.**', 'password1': 'zxnm11a!s', 'password2': 'zxnm11a!s' } self.client.post(reverse('signup'), user1, follow=True) self.client.login(username="******", password="******") self.group = Group.objects.create(title='test123', slug='test', description='testing') self.text = 'cache text' with open('media/testimg.jpg', 'rb') as fp: self.client.post(reverse('new_post'), { 'text': 'fred', 'image': fp, 'group': 1 }, follow=True) def test_post_image_index(self): response = self.client.get('/') self.assertEqual(response.status_code, 200) self.assertIn('<img', response.content.decode()) def test_post_image(self): response = self.client.get('/sarah/1/') self.assertEqual(response.status_code, 200) self.assertIn('<img', response.content.decode()) def test_post_image_edit(self): response = self.client.get('/group/test/') self.assertEqual(response.status_code, 200) self.assertIn('<img', response.content.decode()) def test_not_image(self): with open('media/test.txt', 'rb') as fp: response = self.client.post(reverse('new_post'), { 'text': 'fred', 'image': fp, 'group': 1 }) self.assertFormError( response, 'form', 'image', errors= ('Загрузите правильное изображение. Файл, который вы загрузили, поврежден или не является изображением.' )) def test_cache_with_creating_new_post(self): self.client.post(reverse('new_post'), {'text': self.text, 'group': 1}) Post.objects.get(pk=2) response = self.client.get('/') self.assertNotContains(response, self.text, status_code=200, msg_prefix='', html=False) time.sleep(20) response = self.client.get('/') self.assertContains(response, self.text, status_code=200, msg_prefix='', html=False)
class ViewsTestLogged(TestCase): def setUp(self): self.client = Client() self.user = PyDayUser.objects._create_user("*****@*****.**", "secret", "MynameisWhat", "MynameisWho") self.client.login(email='*****@*****.**', password='******') def test_main(self): with self.assertTemplateUsed('main.html'): response = self.client.get(reverse('pyday_social_network:main')) self.assertEqual(response.status_code, 200) def test_logout(self): with self.assertTemplateUsed('error.html'): response = self.client.get(reverse('pyday_social_network:logout')) self.assertEqual(response.status_code, 200) def test_display_all_users(self): self.display('pyday_social_network:all_users') def display(self, name_url): with self.assertTemplateUsed('all_users.html'): response = self.client.get(reverse(name_url)) self.assertEqual(response.status_code, 200) def test_display_following(self): self.display('pyday_social_network:following') def test_display_followers(self): self.display('pyday_social_network:followers') def test_display_friends(self): self.display('pyday_social_network:friends') def test_follow(self): user2 = PyDayUser.objects._create_user("*****@*****.**", "secret", "MynameisWhat", "MynameisWho") response = self.client.get('/social/follow/{}'.format(user2.id), follow=True) self.assertTrue( PyDayUser.objects.get(email=user2.email) in PyDayUser.objects.get( email=self.user.email).following) self.assertTrue( PyDayUser.objects.get( email=self.user.email) in PyDayUser.objects.get( email=user2.email).followers) self.assertEqual(response.redirect_chain, [('/social/profile', 302), ('/social/profile/', 301)]) def test_follow_already_following(self): user2 = PyDayUser.objects._create_user("*****@*****.**", "secret", "MynameisWhat", "MynameisWho") self.user.follow(user2.id) with self.assertTemplateUsed('error.html'): response = self.client.get('/social/follow/{}'.format(user2.id)) self.assertContains(response, "You have already followed this user") def test_unfollow(self): user2 = PyDayUser.objects._create_user("*****@*****.**", "secret", "MynameisWhat", "MynameisWho") self.user.follow(user2.id) response = self.client.get('/social/unfollow/{}'.format(user2.id), follow=True) self.assertTrue( PyDayUser.objects.get( email=user2.email) not in PyDayUser.objects.get( email=self.user.email).following) self.assertTrue( PyDayUser.objects.get( email=self.user.email) not in PyDayUser.objects.get( email=user2.email).followers) self.assertEqual(response.redirect_chain, [('/social/profile', 302), ('/social/profile/', 301)]) def test_unfollow_already_not_following(self): user2 = PyDayUser.objects._create_user("*****@*****.**", "secret", "MynameisWhat", "MynameisWho") with self.assertTemplateUsed('error.html'): response = self.client.get('/social/unfollow/{}'.format(user2.id)) self.assertContains(response, "You do not follow this user") def test_display_profile(self): with self.assertTemplateUsed('profile.html'): response = self.client.get("/social/profile/{}".format( self.user.id)) self.assertEqual(response.status_code, 200) def test_display_non_existing(self): with self.assertTemplateUsed('error.html'): response = self.client.get("/social/profile/100") self.assertContains(response, 'User does not exist.')
class TestViews(TestCase): """ Test whether views render at all. """ fixtures = [ 'dsmr_frontend/test_dsmrreading.json', 'dsmr_frontend/test_note.json', 'dsmr_frontend/EnergySupplierPrice.json', 'dsmr_frontend/test_statistics.json', 'dsmr_frontend/test_meterstatistics.json', ] namespace = 'frontend' support_data = True support_gas = True def setUp(self): self.client = Client() self.user = User.objects.create_user('testuser', 'unknown@localhost', 'passwd') dsmr_consumption.services.compact_all() def test_admin(self): response = self.client.get(reverse('admin:index')) self.assertEqual(response.status_code, 302) self.assertEqual(response['Location'], '/admin/login/?next=/admin/') @mock.patch('dsmr_frontend.views.dashboard.Dashboard.get_context_data') def test_http_500_production(self, get_context_data_mock): get_context_data_mock.side_effect = SyntaxError('Meh') response = self.client.get( reverse('{}:dashboard'.format(self.namespace))) self.assertEqual(response.status_code, 500) @mock.patch('django.conf.settings.DEBUG') @mock.patch('dsmr_frontend.views.dashboard.Dashboard.get_context_data') def test_http_500_development(self, get_context_data_mock, debug_setting_mock): """ Verify that the middleware is allowing Django to jump in when not in production. """ get_context_data_mock.side_effect = SyntaxError('Meh') debug_setting_mock.return_value = True with self.assertRaises(SyntaxError): self.client.get(reverse('{}:dashboard'.format(self.namespace))) @mock.patch('django.utils.timezone.now') def test_dashboard(self, now_mock): now_mock.return_value = timezone.make_aware( timezone.datetime(2015, 11, 15)) weather_settings = WeatherSettings.get_solo() weather_settings.track = True weather_settings.save() response = self.client.get( reverse('{}:dashboard'.format(self.namespace))) self.assertEqual(response.status_code, 200) self.assertIn('track_temperature', response.context) if self.support_data: self.assertIn('consumption', response.context) @mock.patch('django.utils.timezone.now') def test_dashboard_xhr_header(self, now_mock): now_mock.return_value = timezone.make_aware( timezone.datetime(2015, 11, 15)) # This makes sure all possible code paths are covered. for current_tariff in (None, 1, 2): if MeterStatistics.objects.exists(): meter_statistics = MeterStatistics.get_solo() meter_statistics.electricity_tariff = current_tariff meter_statistics.save() response = self.client.get( reverse('{}:dashboard-xhr-header'.format(self.namespace))) self.assertEqual(response.status_code, 200, response.content) self.assertEqual(response['Content-Type'], 'application/json') # No response when no data at all. if self.support_data: json_response = json.loads(response.content.decode("utf-8")) self.assertIn('timestamp', json_response) self.assertIn('currently_delivered', json_response) self.assertIn('currently_returned', json_response) # Costs only makes sense when set. if EnergySupplierPrice.objects.exists() and MeterStatistics.objects.exists() \ and current_tariff is not None: self.assertIn('latest_electricity_cost', json_response) self.assertEqual(json_response['latest_electricity_cost'], '0.23' if current_tariff == 1 else '0.46') @mock.patch('django.utils.timezone.now') def test_dashboard_xhr_graphs(self, now_mock): now_mock.return_value = timezone.make_aware( timezone.datetime(2015, 11, 15)) if self.support_data: weather_settings = WeatherSettings.get_solo() weather_settings.track = True weather_settings.save() # Test with phases feature switched on as well. DataloggerSettings.get_solo() DataloggerSettings.objects.update(track_phases=True) # Send seperate offset as well. response = self.client.get(reverse('{}:dashboard-xhr-graphs'.format( self.namespace)), data={'electricity_offset': 24}) self.assertEqual(response.status_code, 200, response.content) # Send invalid offset. response = self.client.get(reverse('{}:dashboard-xhr-graphs'.format( self.namespace)), data={'electricity_offset': 'abc'}) self.assertEqual(response.status_code, 400) response = self.client.get( reverse('{}:dashboard-xhr-graphs'.format(self.namespace))) self.assertEqual(response.status_code, 200, response.content) json_content = json.loads(response.content.decode("utf8")) if self.support_data: self.assertGreater(len(json_content['electricity_x']), 0) self.assertGreater(len(json_content['electricity_y']), 0) self.assertIn('phases_l1_y', json_content) self.assertIn('phases_l2_y', json_content) self.assertIn('phases_l3_y', json_content) if self.support_gas: self.assertGreater(len(json_content['gas_x']), 0) self.assertGreater(len(json_content['gas_y']), 0) def test_dashboard_xhr_notification_read(self): view_url = reverse('{}:dashboard-xhr-notification-read'.format( self.namespace)) notification = Notification.objects.create(message='TEST', redirect_to='fake') self.assertFalse(notification.read) response = self.client.post(view_url, data={'notification_id': notification.pk}) self.assertEqual(response.status_code, 200) # Notification should be altered now. notification.refresh_from_db() self.assertTrue(notification.read) @mock.patch('django.utils.timezone.now') def test_archive(self, now_mock): now_mock.return_value = timezone.make_aware( timezone.datetime(2016, 1, 1)) response = self.client.get(reverse('{}:archive'.format( self.namespace))) self.assertEqual(response.status_code, 200) self.assertIn('capabilities', response.context) # XHR's. data = { 'date': formats.date_format(timezone.now().date(), 'DSMR_DATEPICKER_DATE_FORMAT'), } for current_level in ('days', 'months', 'years'): # Test both with tariffs sparated and merged. for merge in (False, True): frontend_settings = FrontendSettings.get_solo() frontend_settings.merge_electricity_tariffs = merge frontend_settings.save() data.update({'level': current_level}) response = self.client.get(reverse( '{}:archive-xhr-summary'.format(self.namespace)), data=data) self.assertEqual(response.status_code, 200) response = self.client.get(reverse( '{}:archive-xhr-graphs'.format(self.namespace)), data=data) self.assertEqual(response.status_code, 200, response.content) # Invalid XHR. data.update({'level': 'INVALID DATA'}) response = self.client.get(reverse('{}:archive-xhr-summary'.format( self.namespace)), data=data) self.assertEqual(response.status_code, 500) response = self.client.get(reverse('{}:archive-xhr-graphs'.format( self.namespace)), data=data) self.assertEqual(response.status_code, 500) @mock.patch('django.utils.timezone.now') def test_statistics(self, now_mock): now_mock.return_value = timezone.make_aware( timezone.datetime(2016, 1, 1)) response = self.client.get( reverse('{}:statistics'.format(self.namespace))) self.assertEqual(response.status_code, 200) self.assertIn('capabilities', response.context) if DsmrReading.objects.exists(): self.assertIn('latest_reading', response.context) def test_statistics_xhr_data(self): response = self.client.get( reverse('{}:statistics-xhr-data'.format(self.namespace))) self.assertEqual(response.status_code, 200, response.content) self.assertEqual(response['Content-Type'], 'application/json') json_response = json.loads(response.content.decode("utf-8")) self.assertIn('total_reading_count', json_response) self.assertIn('slumber_consumption_watt', json_response) self.assertIn('min_consumption_watt', json_response) self.assertIn('max_consumption_watt', json_response) @mock.patch('django.utils.timezone.now') def test_trends(self, now_mock): now_mock.return_value = timezone.make_aware( timezone.datetime(2016, 1, 1)) response = self.client.get(reverse('{}:trends'.format(self.namespace))) self.assertEqual(response.status_code, 200) self.assertIn('capabilities', response.context) self.assertIn('day_statistics_count', response.context) self.assertIn('hour_statistics_count', response.context) if 'avg_consumption_x' in response.context: self.assertIn('electricity_by_tariff_week', response.context) self.assertIn('electricity_by_tariff_month', response.context) # Test with missing electricity returned. ElectricityConsumption.objects.all().update(currently_returned=0) response = self.client.get(reverse('{}:trends'.format(self.namespace))) self.assertEqual(response.status_code, 200) self.assertFalse( response.context['capabilities']['electricity_returned']) @mock.patch('django.utils.timezone.now') def test_compare(self, now_mock): """ Basicly the same view (context vars) as the archive view. """ now_mock.return_value = timezone.make_aware( timezone.datetime(2016, 1, 1)) response = self.client.get(reverse('{}:compare'.format( self.namespace))) self.assertEqual(response.status_code, 200) self.assertIn('capabilities', response.context) @mock.patch('django.utils.timezone.now') def test_status(self, now_mock): now_mock.return_value = timezone.make_aware( timezone.datetime(2016, 1, 1)) response = self.client.get(reverse('{}:status'.format(self.namespace))) self.assertEqual(response.status_code, 200) self.assertIn('capabilities', response.context) self.assertIn('unprocessed_readings', response.context) if self.support_data: self.assertIn('latest_day_statistics', response.context) self.assertIn('days_since_latest_day_statistics', response.context) if 'latest_reading' in response.context: self.assertIn('delta_since_latest_reading', response.context) if 'latest_ec' in response.context: self.assertIn('latest_ec', response.context) self.assertIn('minutes_since_latest_ec', response.context) if 'latest_gc' in response.context: self.assertIn('latest_gc', response.context) self.assertIn('hours_since_latest_gc', response.context) @mock.patch('dsmr_backend.services.is_latest_version') def test_status_xhr_update_checker(self, is_latest_version_mock): for boolean in (True, False): is_latest_version_mock.return_value = boolean response = self.client.get( reverse('{}:status-xhr-check-for-updates'.format( self.namespace))) self.assertEqual(response.status_code, 200, response.content) self.assertEqual(response['Content-Type'], 'application/json') json_response = json.loads(response.content.decode("utf-8")) self.assertIn('update_available', json_response) self.assertEqual( json_response['update_available'], not boolean) # Inverted, because latest = no updates. def test_export(self): view_url = reverse('{}:export'.format(self.namespace)) # Check login required. response = self.client.get(view_url) self.assertEqual(response.status_code, 302) self.assertEqual(response['Location'], 'admin/login/?next={}'.format(view_url)) # Login and retest self.client.login(username='******', password='******') response = self.client.get(view_url) self.assertEqual(response.status_code, 200) self.assertIn('start_date', response.context) self.assertIn('end_date', response.context) def test_export_as_csv(self): view_url = reverse('{}:export-as-csv'.format(self.namespace)) post_data = { 'data_type': ExportAsCsvForm.DATA_TYPE_DAY, 'export_format': ExportAsCsvForm.EXPORT_FORMAT_CSV, 'start_date': '2016-01-01', 'end_date': '2016-02-01', } # Check login required. response = self.client.post(view_url) self.assertEqual(response.status_code, 302) self.assertEqual(response['Location'], 'admin/login/?next={}'.format(view_url)) # Login and retest, without post data. self.client.login(username='******', password='******') response = self.client.post(view_url, ) self.assertEqual(response.status_code, 302) self.assertEqual( # Invalid form redirects to previous page. response['Location'], '{}'.format(reverse('{}:export'.format(self.namespace)))) # Day export. response = self.client.post(view_url, data=post_data) self.assertEqual(response.status_code, 200) io.BytesIO(b"".join( response.streaming_content)) # Force generator evaluation. # Hour export. post_data['data_type'] = ExportAsCsvForm.DATA_TYPE_HOUR response = self.client.post(view_url, data=post_data) self.assertEqual(response.status_code, 200) io.BytesIO(b"".join( response.streaming_content)) # Force generator evaluation. def test_read_the_docs_redirects(self): for current in ('docs', 'feedback'): response = self.client.get( reverse('{}:{}-redirect'.format(self.namespace, current))) self.assertEqual(response.status_code, 302) self.assertTrue(response['Location'].startswith( 'https://dsmr-reader.readthedocs.io'))
class FollowersTest(TestCase): def setUp(self): cache.clear() self.client = Client() user1 = { 'name': 'sarah', 'surname': 'oconnor', 'username': '******', 'email': '*****@*****.**', 'password1': 'zxnm11a!s', 'password2': 'zxnm11a!s' } user2 = { 'name': 'brian', 'surname': 'oconnor', 'username': '******', 'email': '*****@*****.**', 'password1': 'zxnm11a!s', 'password2': 'zxnm11a!s' } self.client.post(reverse('signup'), user1, follow=True) self.client.post(reverse('signup'), user2, follow=True) self.client.login(username="******", password="******") self.group = Group.objects.create(title='test123', slug='test', description='testing') self.text = 'cache text' with open('media/testimg.jpg', 'rb') as fp: self.client.post(reverse('new_post'), { 'text': self.text, 'image': fp, 'group': 1 }, follow=True) self.client.logout() self.client.login(username="******", password="******") # Только авторизированный пользователь может комментировать посты. def test_only_authorised_user_can_make_comments(self): test_comment = 'test_comment' response = self.client.post('/sarah/1/comment/', {'text': test_comment}, follow=True) self.assertEqual(response.status_code, 200) response = self.client.get('/sarah/1/') self.assertContains(response, test_comment, status_code=200, msg_prefix='', html=False) self.client.logout() response = self.client.post('/sarah/1/comment/', {'text': test_comment}, follow=True) self.assertRedirects(response, '/auth/login/?next=%2Fsarah%2F1%2Fcomment%2F', status_code=302, target_status_code=200, msg_prefix='', fetch_redirect_response=True) # Авторизованный пользователь может подписываться на других пользователей и удалять их из подписок. def test_user2_follows_to_user1(self): response = self.client.get('/sarah/follow') author1 = User.objects.get(username='******') follower = Follow.objects.filter(user=author1).count() author2 = User.objects.get(username='******') following = Follow.objects.filter(author=author2).count() self.assertEqual(follower, following) self.assertEqual(follower, 1) response = self.client.get('/sarah/unfollow') follower = Follow.objects.filter(user=author1).count() following = Follow.objects.filter(author=author2).count() self.assertEqual(follower, following) self.assertEqual(follower, 0) # Новая запись пользователя появляется в ленте тех, # кто на него подписан и не появляется в ленте тех, кто не подписан на него. def test_new_post_is_shown_in_favourite_users(self): response = self.client.get('/sarah/follow') response = self.client.get('/follow/') self.assertContains(response, self.text, status_code=200, msg_prefix='', html=False) response = self.client.get('/sarah/unfollow') response = self.client.get('/follow/') self.assertNotContains(response, self.text, status_code=200, msg_prefix='', html=False) Post.objects.create(author=User.objects.get(username='******'), text='favourite users') response = self.client.get('/follow/') self.assertNotContains(response, 'favourite users', status_code=200, msg_prefix='', html=False) response = self.client.get('/sarah/follow') response = self.client.get('/follow/') self.assertContains(response, self.text, status_code=200, msg_prefix='', html=False)
def test_ambulance_post_view(self): # instantiate client client = Client() # login as admin client.login(username=settings.MQTT['USERNAME'], password=settings.MQTT['PASSWORD']) # create ambulance response = client.post( '/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('/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( '/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( '/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( '/api/ambulance/', { 'identifier': 'NEW-NEW-1897', 'capability': AmbulanceCapability.B.name, 'comment': 'more comments' }) self.assertEqual(response.status_code, 403) # logout client.logout()
def test_layer_replace(self): """Test layer replace functionality """ vector_file = os.path.join( gisdata.VECTOR_DATA, 'san_andres_y_providencia_administrative.shp') vector_layer = file_upload(vector_file, overwrite=True) raster_file = os.path.join(gisdata.RASTER_DATA, 'test_grid.tif') raster_layer = file_upload(raster_file, overwrite=True) c = Client() c.login(username='******', password='******') #test the program can determine the original layer in raster type raster_replace_url = reverse('layer_replace', args=[raster_layer.typename]) response = c.get(raster_replace_url) self.assertEquals(response.status_code, 200) self.assertEquals(response.context['is_featuretype'], False) #test the program can determine the original layer in vector type vector_replace_url = reverse('layer_replace', args=[vector_layer.typename]) response = c.get(vector_replace_url) self.assertEquals(response.status_code, 200) self.assertEquals(response.context['is_featuretype'], True) #test replace a vector with a raster response = c.post(vector_replace_url, {'base_file': open(raster_file)}) # TODO: This should really return a 400 series error with the json dict self.assertEquals(response.status_code, 200) response_dict = json.loads(response.content) self.assertEquals(response_dict['success'], False) #test replace a vector with a different vector new_vector_file = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp') layer_path, __ = os.path.splitext(new_vector_file) layer_base = open(layer_path + '.shp') layer_dbf = open(layer_path + '.dbf') layer_shx = open(layer_path + '.shx') layer_prj = open(layer_path + '.prj') response = c.post( vector_replace_url, { 'base_file': layer_base, 'dbf_file': layer_dbf, 'shx_file': layer_shx, 'prj_file': layer_prj }) self.assertEquals(response.status_code, 200) response_dict = json.loads(response.content) self.assertEquals(response_dict['success'], True) # Get a Layer object for the newly created layer. new_vector_layer = Layer.objects.get(pk=vector_layer.pk) #FIXME(Ariel): Check the typename does not change. #Test the replaced layer is indeed different from the original layer self.assertNotEqual(vector_layer.bbox_x0, new_vector_layer.bbox_x0) self.assertNotEqual(vector_layer.bbox_x1, new_vector_layer.bbox_x1) self.assertNotEqual(vector_layer.bbox_y0, new_vector_layer.bbox_y0) self.assertNotEqual(vector_layer.bbox_y1, new_vector_layer.bbox_y1) #test an invalid user without layer replace permission c.logout() c.login(username='******', password='******') response = c.post( vector_replace_url, { 'base_file': layer_base, 'dbf_file': layer_dbf, 'shx_file': layer_shx, 'prj_file': layer_prj }) self.assertEquals(response.status_code, 403)
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('/api/ambulance/{}/'.format(str(self.a1.id))) 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('/api/ambulance/{}/'.format(str(self.a1.id)), content_type='application/json', data=json.dumps({ 'status': status, })) 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('/api/ambulance/{}/'.format(str(self.a1.id))) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertEqual(result['status'], status) # set status location location_timestamp = timezone.now() location = {'latitude': -2., 'longitude': 7.} response = client.patch('/api/ambulance/{}/'.format(str(self.a1.id)), content_type='application/json', data=json.dumps({ 'location': point2str(location), 'location_timestamp': date2iso(location_timestamp), })) 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 location response = client.get('/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['location_timestamp'], date2iso(location_timestamp)) # set wrong attribute response = client.patch('/api/ambulance/{}/'.format(str(self.a1.id)), content_type='application/json', data=json.dumps({'status': 'will fail'})) self.assertEqual(response.status_code, 400) # set wrong ambulance id response = client.patch('/api/ambulance/100/', data=json.dumps({'status': status})) self.assertEqual(response.status_code, 404) # logout client.logout() # login as testuser2 client.login(username='******', password='******') # retrieve ambulance response = client.get('/api/ambulance/{}/'.format(str(self.a3.id))) 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('/api/ambulance/{}/'.format(str(self.a3.id)), content_type='application/json', data=json.dumps({ 'status': status, })) 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('/api/ambulance/{}/'.format(str(self.a3.id))) self.assertEqual(response.status_code, 200) result = JSONParser().parse(BytesIO(response.content)) self.assertEqual(result['status'], status) # set status location location_timestamp = timezone.now() location = {'latitude': -2., 'longitude': 7.} response = client.patch('/api/ambulance/{}/'.format(str(self.a3.id)), content_type='application/json', data=json.dumps({ 'location': point2str(location), 'location_timestamp': date2iso(location_timestamp), })) 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 location response = client.get('/api/ambulance/{}/'.format(str(self.a3.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['location_timestamp'], date2iso(location_timestamp)) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/api/ambulance/{}/'.format(str(self.a1.id)), content_type='application/json', data=json.dumps({ 'status': status, })) self.assertEqual(response.status_code, 404) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/api/ambulance/{}/'.format(str(self.a2.id)), content_type='application/json', data=json.dumps({ 'status': status, })) 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('/api/ambulance/{}/'.format(str(self.a1.id)), content_type='application/json', data=json.dumps({ 'status': status, })) self.assertEqual(response.status_code, 404) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/api/ambulance/{}/'.format(str(self.a2.id)), content_type='application/json', data=json.dumps({ 'status': status, })) self.assertEqual(response.status_code, 404) # set status ambulance status = AmbulanceStatus.OS.name response = client.patch('/api/ambulance/{}/'.format(str(self.a3.id)), content_type='application/json', data=json.dumps({ 'status': status, })) self.assertEqual(response.status_code, 404) # logout client.logout()
class QAViewsTest(TestCase): def setUp(self): self.user = self.make_user("first_user") self.other_user = self.make_user("second_user") self.client = Client() self.other_client = Client() self.client.login(username="******", password="******") self.other_client.login(username="******", password="******") self.question_one = Question.objects.create( user=self.user, title="This is a sample question", content="This is a sample question content", tags="test1, test2") self.question_two = Question.objects.create( user=self.user, title="A Short Title", content="""This is a really good content, just if somebody published it, that would be awesome, but no, nobody wants to publish it, because they know this is just a test, and you know than nobody wants to publish a test, just a test; everybody always wants the real deal.""", has_answer=True, tags="test1, test2") self.answer = Answer.objects.create( user=self.user, question=self.question_two, content="A reaaaaally loooong content", is_answer=True) def test_index_questions(self): response = self.client.get(reverse("qa:index_all")) assert response.status_code == 200 assert "A Short Title" in str(response.context["question"]) def test_create_question_view(self): current_count = Question.objects.count() response = self.client.post( reverse("qa:ask_question"), { "title": "Not much of a title", "content": "bablababla bablababla", "status": "O", "tags": "test, tag" }) assert response.status_code == 302 new_question = Question.objects.first() assert new_question.title == "Not much of a title" assert Question.objects.count() == current_count + 1 def test_answered_questions(self): response = self.client.get(reverse("qa:index_ans")) self.assertEqual(response.status_code, 200) self.assertTrue("A Short Title" in str(response.context["question"])) def test_unanswered_questions(self): response = self.client.get(reverse("qa:index_noans")) assert response.status_code == 200 assert "This is a sample question" in str(response.context["question"]) def test_answer_question(self): current_answer_count = Answer.objects.count() response = self.client.post( reverse("qa:propose_answer", kwargs={"question_id": self.question_one.id}), {"content": "A reaaaaally loooong content"}) assert response.status_code == 302 assert Answer.objects.count() == current_answer_count + 1 def test_question_upvote(self): response_one = self.client.post(reverse("qa:question_vote"), { "value": "U", "question": self.question_one.id }, HTTP_X_REQUESTED_WITH="XMLHttpRequest") assert response_one.status_code == 200 def test_question_downvote(self): response_one = self.client.post(reverse("qa:question_vote"), { "value": "D", "question": self.question_one.id }, HTTP_X_REQUESTED_WITH="XMLHttpRequest") assert response_one.status_code == 200 def test_answer_upvote(self): response_one = self.client.post(reverse("qa:answer_vote"), { "value": "U", "answer": self.answer.uuid_id }, HTTP_X_REQUESTED_WITH="XMLHttpRequest") assert response_one.status_code == 200 def test_answer_downvote(self): response_one = self.client.post(reverse("qa:answer_vote"), { "value": "D", "answer": self.answer.uuid_id }, HTTP_X_REQUESTED_WITH="XMLHttpRequest") assert response_one.status_code == 200 def test_accept_answer(self): response_one = self.client.post(reverse("qa:accept_answer"), {"answer": self.answer.uuid_id}, HTTP_X_REQUESTED_WITH="XMLHttpRequest") assert response_one.status_code == 200
class CommentsTest(TestCase): def setUp(self): self.client = Client() self.factory = RequestFactory() def test_validate_comment(self): site = get_current_site().domain user = BlogUser.objects.create_superuser( email="*****@*****.**", username="******", password="******") self.client.login(username='******', password='******') category = Category() category.name = "categoryccc" category.created_time = timezone.now() category.last_mod_time = timezone.now() category.save() article = Article() article.title = "nicetitleccc" article.body = "nicecontentccc" article.author = user article.category = category article.type = 'a' article.status = 'p' article.save() commenturl = reverse( 'comments:postcomment', kwargs={ 'article_id': article.id}) response = self.client.post(commenturl, { 'body': '123ffffffffff' }) self.assertEqual(response.status_code, 200) article = Article.objects.get(pk=article.pk) self.assertEqual(len(article.comment_list()), 0) response = self.client.post(commenturl, { 'body': '123ffffffffff', 'email': user.email, 'name': user.username }) self.assertEqual(response.status_code, 302) article = Article.objects.get(pk=article.pk) self.assertEqual(len(article.comment_list()), 1) parent_comment_id = article.comment_list()[0].id response = self.client.post(commenturl, { 'body': ''' # Title1 ```python import os ``` [url](https://www.lylinux.net/) [ddd](http://www.baidu.com) ''', 'email': user.email, 'name': user.username, 'parent_comment_id': parent_comment_id }) self.assertEqual(response.status_code, 302) article = Article.objects.get(pk=article.pk) self.assertEqual(len(article.comment_list()), 2) comment = Comment.objects.get(id=parent_comment_id) tree = parse_commenttree(article.comment_list(), comment) self.assertEqual(len(tree), 1) data = show_comment_item(comment, True) self.assertIsNotNone(data) s = get_max_articleid_commentid() self.assertIsNotNone(s)
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('/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('/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('/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('/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('/api/ambulance/{}/'.format(str(self.a2.id)), follow=True) self.assertEqual(response.status_code, 404) # can't read response = client.get('/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('/api/ambulance/{}/'.format(str(self.a1.id)), follow=True) self.assertEqual(response.status_code, 404) # retrieve someone else's response = client.get('/api/ambulance/{}/'.format(str(self.a2.id)), follow=True) self.assertEqual(response.status_code, 404) response = client.get('/api/ambulance/{}/'.format(str(self.a1.id)), follow=True) self.assertEqual(response.status_code, 404) # logout client.logout()
class TestLeadModel(object): def setUp(self): self.client = Client() self.user = User.objects.create(username='******', email='*****@*****.**', role="ADMIN") self.user.set_password('password') self.user.save() self.user1 = User.objects.create(first_name="janeLead1", username='******', email='*****@*****.**', role="USER") self.user1.set_password('password') self.user1.save() self.user2 = User.objects.create(first_name="janeLead2", username='******', email='*****@*****.**', role="USER") self.user2.set_password('password') self.user2.save() self.user3 = User.objects.create(first_name="janeLead3", username='******', email='*****@*****.**', role="USER") self.user3.set_password('password') self.user3.save() self.client.login(username='******', password='******') self.account = Account.objects.create(name="account", email="*****@*****.**", phone="12345", billing_address_line="", billing_street="billing street", billing_city="city of billing", billing_state="state", billing_postcode="1234", billing_country="AD", website="www.example.com", industry="IT", description="account", created_by=self.user) self.lead = Lead.objects.create(title="john lead", first_name="jane doe", last_name="doe", email="*****@*****.**", address_line="address line", street="address street", city="city name", state="state name", postcode="2134", country="IN", website="www.example.com", status="assigned", source="call", opportunity_amount="700", description="lead description", created_by=self.user, account_name="account", phone="+91-123-456-7890") self.lead1 = Lead.objects.create(title="jane doe lead", created_by=self.user3) self.lead.assigned_to.add(self.user) self.lead.assigned_to.add(self.user3) self.case = Case.objects.create(name="john case", case_type="Problem", status="New", account=self.account, priority="Low", description="description", created_by=self.user, closed_on="2016-05-04") self.comment = Comment.objects.create(comment='comment text', case=self.case, commented_by=self.user) self.comment_mp = Comment.objects.create(comment='comment body', case=self.case, commented_by=self.user2) self.attachment = Attachments.objects.create(attachment='image.png', case=self.case, created_by=self.user, account=self.account, lead=self.lead) self.api_seetings = APISettings.objects.create(title="api", apikey="api", created_by=self.user) self.tag_1 = Tags.objects.create(name='tag1') self.tag_2 = Tags.objects.create(name='tag2') self.tag_3 = Tags.objects.create(name='tag3') self.lead.tags.add(self.tag_1, self.tag_2, self.tag_3) self.lead_1 = Lead.objects.create(title="john's lead", first_name="lead first name", last_name="lead last name", address_line="address line", street=" street", city="city", state="state name", postcode="1234", country="IN", website="www.example.com", status="assigned", source="call", opportunity_amount="700", description="Iam an Lead", created_by=self.user, phone="+91-123-456-7890")
class AddStudentsTestCase(TestCase): def setUp(self): self.client = Client() User.objects.create_user('admin', '*****@*****.**', 'admin.password') Admin.objects.create(user=User.objects.get(username='******')) self.client.login(username='******', password='******') def test_addStudents_missing_fields(self): response = self.client.post( '/addStudents/', { 'CSVFile': SimpleUploadedFile(b'test.csv', b'email@email\nemail1@email,12345') }) template_name = 'main/error.html' context = { 'err_at': 'email@email', 'err_msg': 'The csv file does not have required number of columns' } self.assertEqual(response.status_code, 200) self.assertEqual(response.context['err_msg'], context['err_msg']) self.assertEqual(response.context['err_at'], context['err_at']) self.assertTemplateUsed(response, template_name) def test_addStudents_empty_fields(self): response = self.client.post( '/addStudents/', { 'CSVFile': SimpleUploadedFile(b'test.csv', b'email@email,\nemail1@email,12345') }) template_name = 'main/error.html' context = { 'err_at': 'email@email, ', 'err_msg': 'One of the fields seems to be empty' } self.assertEqual(response.status_code, 200) self.assertEqual(response.context['err_msg'], context['err_msg']) self.assertEqual(response.context['err_at'], context['err_at']) self.assertTemplateUsed(response, template_name) def test_addStudents_spclcharacter_fields(self): response = self.client.post( '/addStudents/', { 'CSVFile': SimpleUploadedFile(b'test.csv', b'email@email,12345\nemail1@email,12!#$#$') }) template_name = 'main/error.html' context = { 'err_at': 'email1@email, 12!#$#$', 'err_msg': 'One of the fields seems to have special characters' } self.assertEqual(response.status_code, 200) self.assertEqual(response.context['err_msg'], context['err_msg']) self.assertEqual(response.context['err_at'], context['err_at']) self.assertTemplateUsed(response, template_name) def test_addStudents_valid_example(self): response = self.client.post( '/addStudents/', { 'CSVFile': SimpleUploadedFile( b'test.csv', b'[email protected],is12\[email protected],is22\n') }) template_name = 'main/tables.html' #context = {'model_name':'Students','err_msg':'One of the fields seems to have special characters'} self.assertEqual(response.status_code, 200) self.assertContains(response, 'Student') ### assert other context items as well self.assertTemplateUsed(response, template_name)
class HomeTests(NmkUnitTestCase): def test_anon_user(self): client = Client() response = client.get(reverse(views.home)) self.assertEqual(response.status_code, 302) @NmkUnitTestCase.assertNumQueriesLessThan(16) def test_no_active_round(self): """ Test home view when there is no active rounds """ # Remove current active round response = self.client.get('{}?set_inactive={}'.format( reverse(views.admin_rounds), 3)) self.assertEqual(response.status_code, 200) response = self.client.get(reverse(views.home)) self.assertEqual(response.status_code, 200) context = response.context self.assertEqual(len(context['shots']), 0) self.assertEqual(len(context['messages']), 1) self.assertEqual( list(context['messages'])[0].message, 'There is no active round currently to place bets, try again later' ) def test_active_round_in_past(self): """ Tests that player cannot play match from past """ self.client = Client() self.assertTrue( self.client.login(username='******', password='******')) round = models.Round.objects.filter(name='Final')[0] round.active = True round.save() response = self.client.get(reverse(views.home)) self.assertEqual(response.status_code, 200) context = response.context self.assertEqual(len(context['bets']), 1) bet = context['bets'][0] self.assertEqual(bet['time_left'], 'first match already started') self.assertEqual(bet['round'].id, 3) self.assertIsNone(bet['form']) self.assertEqual(len(bet['shots']), 1) self.assertEqual(bet['shots'][0].match.id, 5) self.assertIsNone(bet['shots'][0].shot) def test_active_round_already_played(self): """ Tests that player who already clicked "final answer" have proper data displayed """ round = models.Round.objects.filter(name='Final')[0] round.active = True round.save() match = models.Match.objects.filter(id=5)[0] match.start_time = datetime.datetime.now() + datetime.timedelta( days=2, hours=12) match.save() response = self.client.get(reverse(views.home)) self.assertEqual(response.status_code, 200) context = response.context self.assertEqual(len(context['bets']), 1) bet = context['bets'][0] self.assertTrue('2d' in bet['time_left']) self.assertEqual(bet['round'].id, 3) self.assertIsNone(bet['form']) self.assertEqual(len(bet['shots']), 1) self.assertEqual(bet['shots'][0].match.id, 5) self.assertEqual(bet['shots'][0].shot, 0) @NmkUnitTestCase.assertNumQueriesLessThan(35) def test_active_round_playable(self): """ Tests that player who is eligible to play can actually play """ self.client = Client() self.assertTrue( self.client.login(username='******', password='******')) round = models.Round.objects.filter(name='Final')[0] round.active = True round.save() match = models.Match.objects.filter(id=5)[0] match.start_time = datetime.datetime.now() + datetime.timedelta( days=2, hours=12) match.save() response = self.client.get(reverse(views.home)) self.assertEqual(response.status_code, 200) context = response.context self.assertEqual(len(context['bets']), 1) bet = context['bets'][0] self.assertTrue('2d' in bet['time_left']) self.assertEqual(bet['round'].id, 3) self.assertIsNotNone(bet['form']) self.assertEqual(len(bet['shots']), 1) self.assertEqual(bet['shots'][0].match.id, 5) self.assertIsNone(bet['shots'][0].shot) def test_play_round_save(self): """ Tests that player who is eligible to play to save """ self.client = Client() self.assertTrue( self.client.login(username='******', password='******')) round = models.Round.objects.filter(name='Final')[0] round.active = True round.save() match = models.Match.objects.filter(id=5)[0] match.start_time = datetime.datetime.now() + datetime.timedelta( days=2, hours=12) match.save() response = self.client.post(reverse(views.home), { 'save_3': None, '8_5': 2 }) self.assertEqual(response.status_code, 302) self.assertEqual(reverse(views.home), response['location']) # Visit page again to see if our bets are saved response = self.client.get(reverse(views.home)) self.assertEqual(response.status_code, 200) context = response.context self.assertEqual(len(context['bets']), 1) bet = context['bets'][0] self.assertEqual(bet['round'].id, 3) self.assertIsNotNone(bet['form']) self.assertEqual(len(bet['shots']), 1) self.assertEqual(bet['shots'][0].match.id, 5) self.assertEqual(bet['shots'][0].shot, 2) def test_play_round_final_save(self): """ Tests that player who is eligible to play to do final save """ self.client = Client() self.assertTrue( self.client.login(username='******', password='******')) round = models.Round.objects.filter(name='Final')[0] round.active = True round.save() match = models.Match.objects.filter(id=5)[0] match.start_time = datetime.datetime.now() + datetime.timedelta( days=2, hours=12) match.save() response = self.client.post(reverse(views.home), { 'final_save_3': None, '8_5': 0 }) self.assertEqual(response.status_code, 302) self.assertEqual(reverse(views.home), response['location']) # Visit page again to see if our bets are saved and we cannot play again response = self.client.get(reverse(views.home)) self.assertEqual(response.status_code, 200) context = response.context self.assertEqual(len(context['bets']), 1) bet = context['bets'][0] self.assertTrue('2d' in bet['time_left']) self.assertEqual(bet['round'].id, 3) self.assertIsNone(bet['form']) self.assertEqual(len(bet['shots']), 1) self.assertEqual(bet['shots'][0].match.id, 5) self.assertEqual(bet['shots'][0].shot, 0)
def test_redirect_student(self): c = Client() c.login(username="******", password="******") response = c.get("/") self.assertEqual(response.url, 'http://testserver/student/dashboard/')
def test_root(self): c = Client() c.login(username='******', password='******') response = c.get('/', follow=True) self.assertEqual(response.status_code, 200)
class PermissionTestCases(TestCase): fixtures = ['privilege.json'] def setUp(self): TestCase.setUp(self) self.client = Client() def tearDown(self): self.client.logout() TestCase.tearDown(self) def test_permission_list_not_login(self): permission_list_url = reverse( "privilege.views.permission.permission_list") self.check_not_login(permission_list_url) def test_permission_list_not_superuser(self): permission_list_url = reverse( "privilege.views.permission.permission_list") self.check_not_superuser(permission_list_url) def test_permission_list_ok(self): permission_list_url = reverse( "privilege.views.permission.permission_list") self.client.login(username="******", password="******") response = self.client.get(permission_list_url) self.assertEqual(response.status_code, 200) self.assertTrue(response.context["permissions"] is not None) def test_add_permission_not_login(self): add_permission_url = reverse( "privilege.views.permission.add_permission") self.check_not_login(add_permission_url) def test_add_permission_not_superuser(self): add_permission_url = reverse( "privilege.views.permission.add_permission") self.check_not_superuser(add_permission_url) def test_add_permission_not_post(self): add_permission_url = reverse( "privilege.views.permission.add_permission") self.client.login(username="******", password="******") response = self.client.get(add_permission_url) self.assertEqual(response.status_code, 200) self.assertTrue(response.context["form"]) def test_add_permission_post_blank(self): add_permission_url = reverse( "privilege.views.permission.add_permission") self.client.login(username="******", password="******") response = self.client.post(add_permission_url, { "name": "", "content_type": "", "codename": "" }) self.assertEqual(response.status_code, 200) self.assertTrue(response.context["form"].errors) def test_add_permission_ok(self): content_type_id = self.prepare_content_type() add_permission_url = reverse( "privilege.views.permission.add_permission") self.client.login(username="******", password="******") response = self.client.post( add_permission_url, { "name": "add_test_cases", "content_type": content_type_id, "codename": "xxx" }) if content_type_id: self.assertEqual(response.status_code, 302) new_permission = Permission.objects.filter(name="add_test_cases") self.assertTrue(new_permission.count()) new_permission.delete() cache.set(PERMISSION_CACHE_KEY, None) else: self.assertEqual(response.status_code, 200) self.assertTrue(response.context["form"].errors) def test_delete_permissions_not_login(self): delete_permission_url = reverse( "privilege.views.permission.delete_permissions") self.check_not_login(delete_permission_url) def test_delete_permissions_not_superuser(self): delete_permission_url = reverse( "privilege.views.permission.delete_permissions") self.check_not_superuser(delete_permission_url) def test_delete_permissions_balnk_string(self): delete_permission_url = reverse( "privilege.views.permission.delete_permissions") self.client.login(username="******", password="******") response = self.client.post(delete_permission_url, {"permission": ""}) self.assertEqual(response.status_code, 302) def test_delete_permissions_not_exists(self): delete_permission_url = reverse( "privilege.views.permission.delete_permissions") self.client.login(username="******", password="******") response = self.client.post(delete_permission_url, {"permission": "-100"}) self.assertEqual(response.status_code, 302) def test_delete_permissions_ok(self): delete_permission_url = reverse( "privilege.views.permission.delete_permissions") self.client.login(username="******", password="******") response = self.client.post(delete_permission_url, {"permission": "100"}) self.assertEqual(response.status_code, 302) delete_permission = Permission.objects.filter(id=100) self.assertFalse(delete_permission.count()) cache.set(PERMISSION_CACHE_KEY, None) def test_change_permission_not_login(self): change_permission_url = reverse( "privilege.views.permission.change_permission", args=(1, )) self.check_not_login(change_permission_url) def test_change_permission_not_super(self): change_permission_url = reverse( "privilege.views.permission.change_permission", args=(1, )) self.check_not_superuser(change_permission_url) def test_change_permission_not_post(self): change_permission_url = reverse( "privilege.views.permission.change_permission", args=(1, )) self.client.login(username="******", password="******") response = self.client.get(change_permission_url) self.assertEqual(response.status_code, 200) self.assertTrue(response.context["form"]) self.assertEqual(response.context["button"], _("Change")) def test_change_permission_post_blank(self): change_permission_url = reverse( "privilege.views.permission.change_permission", args=(1, )) self.client.login(username="******", password="******") response = self.client.post(change_permission_url) self.assertEqual(response.status_code, 200) self.assertTrue(response.context["form"].errors) self.assertEqual(response.context["button"], _("Change")) def test_change_permission_ok(self): content_type_id = self.prepare_content_type() change_permission_url = reverse( "privilege.views.permission.change_permission", args=(1, )) self.client.login(username="******", password="******") post_data = { "name": "test", "content_type": content_type_id, "codename": "test" } response = self.client.post(change_permission_url, post_data) if content_type_id: self.assertEqual(response.status_code, 302) permission = Permission.objects.get(id=1) self.assertEqual(permission.name, "test") cache.set(PERMISSION_CACHE_KEY, None) else: self.assertEqual(response.status_code, 200) self.assertTrue(response.context["form"].errors) self.assertEqual(response.context["button"], _("Change")) def check_not_login(self, url): response = self.client.get(url) self.assertEqual(response.status_code, 302) def check_not_superuser(self, url): self.client.login(username="******", password="******") response = self.client.get(url) self.assertEqual(response.status_code, 403) def prepare_content_type(self): try: content_type_id = ContentType.objects.filter( app_label__in=ACCESSIBLE_APPS)[0].id except: content_type_id = 0 return content_type_id
class users_roles(TestCase): def setUp(self): self.client = Client() self.user = User.objects.create_superuser('*****@*****.**', 'mp', 'mp') self.user_role = UserRole.objects.create(user=self.user, role='Admin') self.employee = User.objects.create_user('*****@*****.**', 'mp', 'mp') UserRole.objects.create(user=self.employee, role='Admin') # self.employee_role = UserRole.objects.create(user=self.employee, role='Author') def test_users_list(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get('/dashboard/users/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/user/new_list.html') response = self.client.get('/dashboard/users/', {'select_role': ''}) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/users/', {'select_role': 'Admin'}) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/users/', {'select_role': 'Author'}) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/users/', {'select_role': 'Admin'}) self.assertEqual(response.status_code, 200) def test_users_edit_delete(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get('/dashboard/user/edit/' + str(self.user.id) + '/') self.assertEqual(response.status_code, 200) # self.assertTemplateUsed(response, 'dashboard/user/new_user_role.html') response = self.client.post( '/dashboard/user/edit/' + str(self.user.id) + '/', {'role': 'Publisher'}) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully Updated User Role' in str(response.content)) response = self.client.post( '/dashboard/user/edit/' + str(self.employee.id) + '/', {'role': 'Author'}) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully Updated User Role' in str(response.content)) response = self.client.post( '/dashboard/user/edit/' + str(self.employee.id) + '/', {'role': ''}) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully Updated User Role' in str(response.content)) response = self.client.get('/dashboard/user/delete/' + str(self.employee.id) + '/') self.assertEqual(response.status_code, 302) response = self.client.get('/dashboard/user/delete/' + str(self.employee.id + 1) + '/') self.assertEqual(response.status_code, 404)
def test_tenants(self): c = Client() c.login(username='******', password='******') reversed = urlresolvers.reverse('tenants') response = c.get(reversed) self.assertEqual(response.status_code, 200)
class django_blog_it_views_get(TestCase): def setUp(self): self.client = Client() self.user = User.objects.create_superuser('*****@*****.**', 'micro-test', 'mp') self.employee = User.objects.create_user('*****@*****.**', 'micro', 'mp') self.category = Category.objects.create(name='django', description='django desc', user=self.user, is_active=True) self.linuxcategory = Category.objects.create(name='linux', description='django desc', user=self.user, is_active=True) self.blogppost = Post.objects.create(title='other python introduction', user=self.user, content='This is content', category=self.category, status='Published', slug="other-python-introduction") self.tag = Tags.objects.create(name='testtag') self.blogppost.tags.add(self.tag) self.pythonpost = Post.objects.create(title='decorator', user=self.user, content='This is content', category=self.category, status='Published', slug="decorator") def test_blog_get(self): response = self.client.get('/dashboard/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/new_admin-login.html') response = self.client.post('/dashboard/', { 'email': '*****@*****.**', 'password': '******' }) self.assertEqual(response.status_code, 200) response = self.client.post('/dashboard/', { 'email': '*****@*****.**', 'password': '******' }) self.assertEqual(response.status_code, 200) response = self.client.post('/dashboard/', { 'email': '*****@*****.**', 'password': '******' }) self.assertEqual(response.status_code, 200) response = self.client.post('/dashboard/', { 'email': '*****@*****.**', 'password': '******' }) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/new_admin-login.html') user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get('/dashboard/view/' + str(self.blogppost.slug) + '/') self.assertEqual(response.status_code, 200) # self.assertTemplateUsed(response, 'dashboard/blog/blog_view.html') response = self.client.get('/dashboard/logout/') self.assertEqual(response.status_code, 302) def test_blog_post(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get('/dashboard/') self.assertEqual(response.status_code, 302) response = self.client.get('/dashboard/blog/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/blog/new_blog_list.html') response = self.client.post('/dashboard/blog/', { 'select_status': '', 'search_text': '' }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/blog/new_blog_list.html') response = self.client.post('/dashboard/blog/', { 'select_status': 'Published', 'search_text': '' }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/blog/new_blog_list.html') response = self.client.post('/dashboard/blog/', { 'select_status': 'Published', 'search_text': str(self.category.id) }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/blog/new_blog_list.html') response = self.client.post('/dashboard/blog/', { 'select_status': '', 'search_text': str(self.category.id) }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/blog/new_blog_list.html') response = self.client.get('/dashboard/category/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/category/new_categories_list.html') response = self.client.post('/dashboard/category/', { 'select_status': '', 'category': [] }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/category/new_categories_list.html') response = self.client.post('/dashboard/category/', { 'select_status': 'True', 'category': [] }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/category/new_categories_list.html') response = self.client.post('/dashboard/category/', { 'select_status': 'False', 'category': [] }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/category/new_categories_list.html') response = self.client.post('/dashboard/category/', { 'select_status': 'Published', 'category': [str(self.category.id)] }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/category/new_categories_list.html') response = self.client.post('/dashboard/category/', { 'select_status': '', 'category': [str(self.category.id)] }) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/category/new_categories_list.html') response = self.client.get('/dashboard/category/add/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/category/new_category_add.html') response = self.client.post( '/dashboard/category/add/', { 'name': 'python', 'description': 'Python description', 'user': str(self.user.id) }) self.assertEqual(response.status_code, 200) self.assertTrue( 'Successfully added your category' in str(response.content)) response = self.client.post('/dashboard/category/add/', {'description': 'python'}) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully added your category' in str(response.content)) response = self.client.get('/dashboard/category/edit/django/') self.assertEqual(response.status_code, 200) response = self.client.post('/dashboard/category/edit/django/', { 'name': 'django', 'description': 'django', 'user': str(self.user.id) }) self.assertEqual(response.status_code, 200) self.assertTrue( 'Successfully updated your category' in str(response.content)) response = self.client.post('/dashboard/category/edit/django/', { 'name': 'jquery', 'description': 'django', 'user': str(self.user.id) }) self.assertEqual(response.status_code, 200) self.assertTrue( 'Successfully updated your category' in str(response.content)) response = self.client.post('/dashboard/category/edit/python/', {'description': 'python'}) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully updated your category' in str(response.content)) def test_blog_with_super_admin(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get('/dashboard/view/' + str(self.blogppost.slug) + '/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/blog/new_blog_view.html') response = self.client.get('/dashboard/upload_photos/', {'CKEditorFuncNum': '/dashboard/'}) self.assertEqual(response.status_code, 200) context = {'CKEditorFuncNum': '/dashboard/'} response = self.client.get('/dashboard/upload_photos/', context) self.assertEqual(response.status_code, 200) # recent photos response = self.client.get('/dashboard/recent_photos/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/browse.html') response = self.client.get('/dashboard/bulk_actions_blog/') self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/bulk_actions_blog/', {'blog_ids[]': [str(self.blogppost.id)]}) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/bulk_actions_blog/', { 'blog_ids[]': [str(self.blogppost.id)], 'action': 'Published' }) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/bulk_actions_blog/', { 'blog_ids[]': [str(self.pythonpost.id)], 'action': 'Delete' }) self.assertEqual(response.status_code, 200) # bulk actions category response = self.client.get('/dashboard/bulk_actions_category/') self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/bulk_actions_category/', {'blog_ids[]': [str(self.category.id)]}) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/bulk_actions_category/', { 'blog_ids[]': [str(self.category.id)], 'action': 'True' }) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/bulk_actions_category/', { 'blog_ids[]': [str(self.linuxcategory.id)], 'action': 'Delete' }) self.assertEqual(response.status_code, 200) response = self.client.get('/dashboard/bulk_actions_category/', { 'blog_ids[]': [str(self.category.id)], 'action': 'False' }) self.assertEqual(response.status_code, 200) # delete category response = self.client.post( '/dashboard/category/add/', { 'name': 'python', 'description': 'Python description', 'user': str(self.user.id) }) response = self.client.get('/dashboard/category/delete/python/') self.assertEqual(response.status_code, 302)
class Pages(TestCase): def setUp(self): self.client = Client() self.user = User.objects.create_superuser('*****@*****.**', 'mp', 'mp') self.user_role = UserRole.objects.create(user=self.user, role='Admin') self.employee = User.objects.create_user('*****@*****.**', 'mp', 'mp') self.page = Page.objects.create(title="test", content="test content", meta_description='page desc', keywords='keywords', meta_title="meta title") def test_pages_list(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get(reverse('pages')) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/pages/new_list.html') response = self.client.get(reverse('pages'), {'select_status': 'True'}) self.assertEqual(response.status_code, 200) response = self.client.get(reverse('pages'), {'select_status': 'False'}) self.assertEqual(response.status_code, 200) response = self.client.get(reverse('bulk_actions_pages'), {'page_ids[]': [str(self.page.id)]}) self.assertEqual(response.status_code, 200) response = self.client.get(reverse('bulk_actions_pages'), { 'page_ids[]': [str(self.page.id)], 'action': 'True' }) self.assertEqual(response.status_code, 200) response = self.client.get(reverse('bulk_actions_pages'), { 'page_ids[]': [str(self.page.id)], 'action': 'False' }) self.assertEqual(response.status_code, 200) response = self.client.get(reverse('bulk_actions_pages'), { 'page_ids[]': [str(self.page.id)], 'action': 'Delete' }) self.assertEqual(response.status_code, 200) response = self.client.get(reverse('bulk_actions_pages'), {'action': 'Delete'}) self.assertEqual(response.status_code, 200) def test_pages_add(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.post( reverse('add_page'), { 'title': 'nginx post', 'content': 'This is content', 'meta_description': 'page meta data', 'meta_title': 'meta title', 'keywords': 'django', }) self.assertEqual(response.status_code, 200) self.assertTrue( 'Successfully added your page' in str(response.content)) response = self.client.post( reverse('add_page'), { 'title': '', 'content': 'This is content', 'meta_description': 'page meta data', 'meta_title': 'meta title', 'keywords': 'django', }) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully added your page' in str(response.content)) response = self.client.get(reverse('add_page')) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/pages/new_add_page.html') response = self.client.get( reverse('edit_page', kwargs={'page_slug': self.page.slug})) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/pages/new_add_page.html') response = self.client.post( reverse('edit_page', kwargs={'page_slug': self.page.slug}), { 'title': '', 'content': 'This is content', 'meta_description': 'page meta data', 'meta_title': 'meta title', 'keywords': 'django', }) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully added your page' in str(response.content)) response = self.client.post( reverse('edit_page', kwargs={'page_slug': self.page.slug}), { 'title': 'Hello world', 'content': 'This is content', 'meta_description': 'page meta data', 'meta_title': 'meta title', 'keywords': 'django', }) self.assertEqual(response.status_code, 200) def test_delete_page(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get( reverse('delete_page', kwargs={'page_slug': self.page.slug})) self.assertEqual(response.status_code, 302) def test_delete_page_404(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) self.user.is_superuser = False self.user.save() response = self.client.get( reverse('delete_page', kwargs={'page_slug': self.page.slug})) self.assertEqual(response.status_code, 302)
class micro_blog_post_data(TestCase): ''' Saving(POST data) data to the database in django ''' def setUp(self): self.client = Client() self.user = User.objects.create_superuser('*****@*****.**', 'micro', 'mp') self.category = Category.objects.create(name='django', description='django desc') self.blogppost = Post.objects.create(title='django introduction', user=self.user, content='This is content', category=self.category, status='D') self.blog_slug = Post_Slugs.objects.create(blog=self.blogppost, slug='django-introduction', is_active=True) def test_blog_post(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get('/blog/') self.assertEqual(response.status_code, 200) response = self.client.get('/blog/?page=1') self.assertEqual(response.status_code, 302) response = self.client.get('/blog/?page=s') self.assertEqual(response.status_code, 200) # with correct input response = self.client.post( '/blog/new-post/', { 'title': 'python introduction 1', 'content': 'This is content', 'category': self.category.id, 'status': 'D', 'tags': 'django', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], 'excerpt': "Description" }) self.assertRedirects(response, '/blog/list/') response = self.client.post( '/blog/new-post/', { 'title': 'introduction', 'content': 'This is content', 'category': self.category.id, 'status': 'D', 'tags': 'django', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], 'excerpt': "Description" }) self.assertRedirects(response, '/blog/list/') response = self.client.post( '/blog/new-post/', { 'title': 'python', 'content': 'This is content', 'category': self.category.id, 'status': 'P', 'tags': 'python', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['test-python'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], 'excerpt': "Description" }) self.assertRedirects(response, '/blog/list/') response = self.client.post( '/blog/new-post/', { 'title': 'Django', 'content': 'This is content', 'category': self.category.id, 'status': 'T', 'tags': 'django', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['django-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], 'excerpt': "Description" }) self.assertRedirects(response, '/blog/list/') response = self.client.post( '/blog/edit-post/python-introduction-1/', { 'title': 'python introduction', 'content': 'This is content', 'category': self.category.id, 'status': 'D', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'slugs-INITIAL_FORMS': ['1'], 'slugs-0-is_active': ['on'], 'slugs-1-id': [''], 'slugs-2-id': [''], 'slugs-3-id': [''], 'excerpt': "Description" }) self.assertRedirects(response, '/blog/list/') response = self.client.post( '/blog/edit-post/python-introduction-1/', { 'title': 'python introduction', 'excerpt': "Description", 'content': 'This is edited content', 'category': self.category.id, 'status': 'P', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': ['python-2'], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'slugs-INITIAL_FORMS': ['1'], 'slugs-0-is_active': ['on'], 'slugs-1-is_active': ['on'] }) self.assertEqual(response.status_code, 200) self.assertEqual(response.context['blog_form'].is_valid(), True) self.assertEqual(response.context['blogslugs_formset'].is_valid(), False) self.assertTrue( '["Only one slug can be active at a time."]' in json.dumps( response.context['blogslugs_formset'].non_form_errors())) response = self.client.post( '/blog/edit-post/python-introduction-1/', { 'title': 'python introduction', 'content': 'This is content', 'category': self.category.id, 'status': 'T', 'tags': 'django', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'slugs-INITIAL_FORMS': ['1'], 'slugs-0-is_active': ['on'], 'excerpt': "Description" }) self.assertRedirects(response, '/blog/list/') response = self.client.post( '/blog/edit-post/python-introduction-1/', { 'content': 'This is content', 'category': self.category.id, 'status': 'D', 'tags': 'python', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'slugs-INITIAL_FORMS': ['1'], 'excerpt': "Description", }) self.assertEqual(response.status_code, 200) self.assertEqual(response.context['blog_form'].is_valid(), False) self.assertTrue('{"title": ["This field is required."]}' in json.dumps( response.context['blog_form'].errors)) response = self.client.post( '/blog/edit-post/python-introduction-1/', { 'title': 'python introduction', 'content': 'This is content', 'category': self.category.id, 'status': 'T', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'excerpt': "Description", 'slugs-INITIAL_FORMS': ['1'], 'slugs-0-is_active': ['on'] }) self.assertRedirects(response, '/blog/list/') response = self.client.post( '/blog/edit-post/python-introduction-1/', { 'title': 'python introduction', 'content': 'This is content', 'category': self.category.id, 'status': 'D', 'meta_description': 'meta', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'slugs-INITIAL_FORMS': ['1'], 'slugs-0-is_active': ['on'], 'slugs-1-is_active': ['on'], 'excerpt': "Description", }) self.assertEqual(response.status_code, 200) self.assertEqual(response.context['blogslugs_formset'].is_valid(), False) self.assertTrue( '[{}, {"slug": ["This field is required."]}, {}, {}]' in json.dumps(response.context['blogslugs_formset'].errors)) response = self.client.get('/blog/edit-post/python-introduction-1/') self.assertEqual(response.status_code, 200) response = self.client.get('/blog/edit-post/test-python/') self.assertEqual(response.status_code, 200) response = self.client.get('/blog/test-python/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'site/blog/article.html') response = self.client.get('/blog/python-introduction-1/') self.assertEqual(response.status_code, 200) response = self.client.post('/blog/new-category/', { 'name': 'django form', 'description': 'django' }) self.assertEqual(response.status_code, 200) self.assertTrue( str('Blog category created') in response.content.decode('utf8')) response = self.client.post('/blog/new-category/', {'description': 'django'}) self.assertEqual(response.status_code, 200) self.assertFalse( str('Blog category created') in response.content.decode('utf8')) response = self.client.get('/blog/edit-category/django/') self.assertEqual(response.status_code, 200) response = self.client.post('/blog/edit-category/django-form/', { 'name': 'django new', 'description': 'django' }) self.assertEqual(response.status_code, 200) self.assertTrue( str('Blog category updated') in response.content.decode('utf8')) response = self.client.post('/blog/edit-category/django-new/', {'description': 'django'}) self.assertEqual(response.status_code, 200) self.assertFalse( str('Blog category updated') in response.content.decode('utf8')) response = self.client.get('/blog/tag/django/') self.assertEqual(response.status_code, 404) response = self.client.get('/blog/tag/django/?page=1') self.assertEqual(response.status_code, 404) response = self.client.get('/blog/tag/django/?page=e') self.assertEqual(response.status_code, 404)
class blog_post_creation(TestCase): def get_author_role(self): self.author_role = UserRole.objects.create(user=self.user, role='Author') def setUp(self): self.client = Client() self.user = User.objects.create_superuser('*****@*****.**', 'mp', 'mp') self.employee = User.objects.create_user('*****@*****.**', 'mp', 'mp') self.category = Category.objects.create(name='salesforce', description='salesforce desc', user=self.user, is_active=True) self.post = Post.objects.create(title="apache", slug="apache", category=self.category, user=self.user) def test_blog_post_add(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.get('/dashboard/add/') self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/blog/new_blog_add.html') response = self.client.post( reverse("blog_add"), { 'title': 'python introduction', 'content': 'This is content', 'category': self.category.id, 'status': 'Published', 'tags': 'django', 'is_superuser': '******', 'slug': 'python-introduction-1', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], }) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully posted your blog' in str(response.content)) response = self.client.post( '/dashboard/add/', { 'title': 'python introduction', 'content': '', 'category': self.category.id, 'status': 'Published', 'tags': 'django', 'is_superuser': '******', 'slug': 'python-introduction-1' }) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully posted your blog' in str(response.content)) response = self.client.post('/dashboard/add/', { 'content': '', 'title': '' }) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully posted your blog' in str(response.content)) response = self.client.post( '/dashboard/add/', { 'title': 'testing', 'content': 'This is content', 'category': self.category.id, 'status': 'Published', 'tags': 'django', 'is_superuser': '******', 'slug': 'testing', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['testing-11223'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], }) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully posted your blog' in str(response.content)) def test_blog_post_edit(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.post( '/dashboard/add/', { 'title': 'nginx post', 'content': 'This is content', 'category': self.category.id, 'status': 'Published', 'tags': 'django', 'is_superuser': '******', 'slug': 'nginx-post', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['testing-11223'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], }) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully posted your blog' in str(response.content)) response = self.client.get( reverse("edit_blog", kwargs={"blog_slug": self.post.slug})) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'dashboard/blog/new_blog_add.html') response = self.client.post( reverse('edit_category', kwargs={"category_slug": self.category.slug}), { 'title': 'nginx-post', 'content': 'This is content', 'category': self.category.id, 'status': 'Published', 'tags': 'django', 'is_superuser': '******', 'slug': 'nginx-post', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['nginx-post-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], }) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully updated your blog post' in str(response.content)) response = self.client.post( reverse("edit_blog", kwargs={"blog_slug": self.post.slug}), { 'title': 'nginx-post', 'content': '', 'category': self.category.id, 'status': 'Published', 'tags': 'django', 'is_superuser': '******', 'slug': 'nginx-post-1' }) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully updated your blog post' in str(response.content)) response = self.client.post( reverse("edit_blog", kwargs={"blog_slug": self.post.slug}), { 'content': '', 'title': '' }) self.assertEqual(response.status_code, 200) self.assertFalse( 'Successfully updated your blog post' in str(response.content)) response = self.client.post( reverse("edit_blog", kwargs={"blog_slug": self.post.slug}), { 'title': 'nginx-post', 'content': 'This is content', 'category': self.category.id, 'status': 'Published', 'tags': 'django', 'is_superuser': '******', 'slug': 'nginx-post-1', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'slugs-INITIAL_FORMS': ['1'], 'slugs-0-is_active': ['on'], 'slugs-1-id': [''], 'slugs-2-id': [''], 'slugs-3-id': [''], }) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully updated your blog post' in str(response.content)) self.post = Post.objects.first() response = self.client.post( reverse("edit_blog", kwargs={"blog_slug": self.post.slug}), { 'title': 'nginx-post', 'content': 'This is content', 'category': self.category.id, 'status': 'Published', 'tags': 'nginx', 'is_superuser': '******', 'slug': 'nginx-post-1', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'slugs-INITIAL_FORMS': ['1'], 'slugs-0-is_active': ['on'], 'slugs-1-id': [''], 'slugs-2-id': [''], 'slugs-3-id': [''], }) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully updated your blog post' in str(response.content)) self.user.is_superuser = False self.user.save() self.get_author_role() response = self.client.post( reverse("edit_blog", kwargs={"blog_slug": self.post.slug}), { 'title': 'nginx-post', 'content': 'This is content', 'category': self.category.id, 'status': 'Published', 'tags': 'nginx', 'is_superuser': '******', 'slug': 'nginx-post-1', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['4'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['python-introduction-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-3-slug': [''], 'slugs-0-id': ['2'], 'slugs-INITIAL_FORMS': ['1'], 'slugs-0-is_active': ['on'], 'slugs-1-id': [''], 'slugs-2-id': [''], 'slugs-3-id': [''], }) self.assertEqual(response.status_code, 200) def test_blog_post_delete(self): user_login = self.client.login(username='******', password='******') self.assertTrue(user_login) response = self.client.post( '/dashboard/add/', { 'title': 'haystack post', 'content': 'This is content', 'category': self.category.id, 'status': 'Published', 'tags': 'django', 'is_superuser': '******', 'slug': 'haystack-post', 'slugs-MAX_NUM_FORMS': ['1000'], 'slugs-TOTAL_FORMS': ['3'], 'slugs-MIN_NUM_FORMS': ['0'], 'slugs-0-slug': ['haystack-post-1'], 'slugs-1-slug': [''], 'slugs-2-slug': [''], 'slugs-INITIAL_FORMS': ['0'], }) self.assertEqual(response.status_code, 200) # self.assertTrue('Successfully posted your blog' in str(response.content)) response = self.client.get( reverse("delete_category", kwargs={"category_slug": self.category.slug})) self.assertEqual(response.status_code, 302) self.post = Post.objects.create(title="apache2", slug="apache2", category=self.category, user=self.user) response = self.client.post( reverse("delete_blog", kwargs={"blog_slug": self.post.slug}), {'action': 'trash'}) self.assertEqual(response.status_code, 302) response = self.client.post( reverse("delete_blog", kwargs={"blog_slug": self.post.slug}), {'action': 'restore'}) self.assertEqual(response.status_code, 302) response = self.client.post( reverse("delete_blog", kwargs={"blog_slug": self.post.slug}), {'action': 'save'}) self.assertEqual(response.status_code, 404) response = self.client.post( reverse("delete_blog", kwargs={"blog_slug": self.post.slug}), {'action': 'delete'}) self.assertEqual(response.status_code, 302) def tearDown(self): super(blog_post_creation, self).tearDown() if hasattr(self, 'author_role'): self.author_role.delete()