Example #1
0
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')
        ]
Example #2
0
 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)
Example #3
0
    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
Example #4
0
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)
Example #5
0
    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
Example #7
0
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('/')
Example #8
0
 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)
Example #9
0
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())
Example #10
0
    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)
Example #11
0
    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)
Example #12
0
    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)
Example #13
0
    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)
Example #14
0
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)
Example #15
0
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
Example #16
0
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)
Example #17
0
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
        )
Example #18
0
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")
Example #19
0
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)
Example #20
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")
Example #21
0
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")
Example #22
0
    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'))
Example #23
0
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)
Example #24
0
    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"))
Example #28
0
    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)
Example #29
0
    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))
Example #30
0
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))
Example #31
0
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)
Example #32
0
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])
Example #33
0
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())
Example #34
0
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)
Example #35
0
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())
Example #36
0
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')
Example #37
0
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])
        })
Example #38
0
    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'
Example #39
0
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)
Example #40
0
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.')
Example #41
0
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'))
Example #42
0
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()
Example #44
0
    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()
Example #46
0
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
Example #47
0
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()
Example #49
0
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")
Example #50
0
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)
Example #51
0
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)
Example #52
0
    def test_redirect_student(self):
        c = Client()
        c.login(username="******", password="******")

        response = c.get("/")
        self.assertEqual(response.url, 'http://testserver/student/dashboard/')
Example #53
0
 def test_root(self):
     c = Client()
     c.login(username='******', password='******')
     response = c.get('/', follow=True)
     self.assertEqual(response.status_code, 200)
Example #54
0
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
Example #55
0
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)
Example #56
0
 def test_tenants(self):
     c = Client()
     c.login(username='******', password='******')
     reversed = urlresolvers.reverse('tenants')
     response = c.get(reversed)
     self.assertEqual(response.status_code, 200)
Example #57
0
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)
Example #58
0
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)
Example #59
0
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)
Example #60
0
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()