Пример #1
0
 def test_optional_email_verification(self):
     c = Client()
     # Signup
     c.get(reverse('account_signup'))
     resp = c.post(
         reverse('account_signup'), {
             'username': '******',
             'email': '*****@*****.**',
             'password1': 'johndoe',
             'password2': 'johndoe'
         })
     # Logged in
     self.assertRedirects(resp,
                          settings.LOGIN_REDIRECT_URL,
                          fetch_redirect_response=False)
     self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
     self.assertEqual(len(mail.outbox), 1)
     # Logout & login again
     c.logout()
     # Wait for cooldown
     EmailConfirmation.objects.update(sent=now() - timedelta(days=1))
     # Signup
     resp = c.post(reverse('account_login'), {
         'login': '******',
         'password': '******'
     })
     self.assertRedirects(resp,
                          settings.LOGIN_REDIRECT_URL,
                          fetch_redirect_response=False)
     self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
     # There was an issue that we sent out email confirmation mails
     # on each login in case of optional verification. Make sure
     # this is not the case:
     self.assertEqual(len(mail.outbox), 1)
Пример #2
0
class ChatPageTest(TestCase):
    """Test the chat test page."""

    # This includes a sample room.
    fixtures = ['test_jqchat.json']

    def setUp(self):
        self.client = Client()
        self.client.login(username='******', password='******')

    def test_chat_page(self):
        """We have a basic test page for the chat client."""

        # Get the room defined in the fixture.
        response = self.client.get('/jqchat/room/1/')
        self.assert_(response.status_code == 200, response.status_code)

        # Basic checks on the content of this page.
        self.assert_('<div id="chatwindow">' in response.content)
        self.assert_(response.context[0]['room'].name == 'The first room',
                     response.context[0]['room'])

    def test_login(self):
        """Must be logged in to access the chat page."""

        self.client.logout()
        response = self.client.get('/jqchat/room/1/')
        # Should redirect to login page.
        self.assert_(response.status_code == 302, response.status_code)
Пример #3
0
 def testQuestion(self):
     client = Client()
     client.login(username='******', password='******')
     resp = client.get('/delphi/create/')
     self.assertEqual(resp.status_code, 200)
     resp = client.post('/delphi/create/', {'question': 'How do I internet?', 'more_info': 'I cannot internet.  How do I internet?  herpderp'})
     self.assertEqual(resp.status_code, 302)
     question1 = Question.objects.get(question='How do I internet?')
     q1id = str(question1.id)
     resp1 = client.get('/delphi/' + q1id + '/')
     self.assertContains(resp1, 'herpderp')
     client.logout()
     client.login(username='******', password='******')
     resp = client.get('/delphi/' + q1id + '/')
     self.assertEqual(resp.status_code, 200)
     self.assertContains(resp, 'herpderp')
     resp = client.get('/delphi/create/')
     self.assertEqual(resp.status_code, 200)
     resp = client.post('/delphi/create/', {'question': 'How do I become less of a noob?', 'more_info': 'My name is Noobert Ownian'})
     self.assertEqual(resp.status_code, 302)
     question2 = Question.objects.get(question='How do I become less of a noob?')
     q2id = str(question2.id)
     resp = client.get('/delphi/' + q2id + '/')
     self.assertEqual(resp.status_code, 200)
     self.assertContains(resp, 'Noobert Ownian')
     client.logout()
Пример #4
0
    def test_lot_login_middleware_always_valid(self):
        c = Client()
        lots = LOT.objects.all().count()

        response = c.get('/test_url/', {'uuid-login': self.lot3.uuid})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(int(c.session['_auth_user_id']), self.lot3.user_id)

        c.logout()
        self.assertFalse("_auth_user_id" in c.session)

        self.assertEqual(LOT.objects.all().count(), lots)

        response = c.get('/test_url/', {'uuid-login': self.lot3.uuid})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(int(c.session['_auth_user_id']), self.lot3.user_id)

        c.logout()
        self.assertFalse("_auth_user_id" in c.session)

        self.assertEqual(LOT.objects.all().count(), lots)

        self.lot3.created = self.lot3.created - datetime.timedelta(days=10000)
        self.lot3.save(force_modification=True)

        response = c.get('/test_url/', {'uuid-login': self.lot3.uuid})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(int(c.session['_auth_user_id']), self.lot3.user_id)

        self.assertEqual(LOT.objects.all().count(), lots)
Пример #5
0
class Login_TestCase(unittest.TestCase):
	def setUp(self):
		self.user = User.objects.create_user(username='******',password='******')
		self.client = Client()

	def tearDown(self):
		self.client.logout()
		self.user.delete()

	def test_index(self):
		"""
		Test an unauthorized page and after the LOGIN_URL.
		"""
		response = self.client.get('/snafu')
		self.assertEqual(response.status_code, 301)
		#self.assertRedirects(response, '/snafu/login?next=/snafu/')
		response = self.client.get('/snafu/login')
		self.assertEqual(response.status_code, 200)

	def test_good_login(self):
		"""
		Test to access to page as a user.
		"""
		self.client.post('/snafu/login', {'username':'******','password':'******'})
		T = self.client.login(username='******',password='******')
		response = self.client.get('/snafu/events')
		self.assertEqual(response.status_code, 200)

	def test_bad_login(self):
		"""
		Test if site is restricted to anonymous users.
		"""
		self.client.post('/snafu/login', {'username':'******','password':'******'})
		response = self.client.post('/snafu/events', {'username':'******','password':'******'})
		self.assertIn(response.status_code, (301,302))
Пример #6
0
 def test_get_sales_leads_product_data(self):
     sl = SalesLeads.objects.create(practice="Cancer Busters",
                                    rep=self.admin.user,
                                    price="99.00")
     c = Client()
     # after successful login should get re-direct to /
     response = c.post('/login/', {
         'username': self.admin.user.username,
         'password': '******'
     })
     self.assertEqual(response.status_code, 302)
     # get product data as admin
     response = c.get(
         reverse('MHLogin.MHLUsers.Sales.views.sales_getproductdata') +
         '?id=' + str(sl.id))
     self.assertEqual(response.status_code, 200, response.status_code)
     response = c.logout()
     self.assertFalse('_auth_user_id' in c.session)
     c = Client()
     # after successful login should get re-direct to /
     response = c.post('/login/', {
         'username': self.salesperson.user.username,
         'password': '******'
     })
     self.assertEqual(response.status_code, 302)
     # get product data as regular sales guy who doesn't have permission
     response = c.get(
         reverse('MHLogin.MHLUsers.Sales.views.sales_getproductdata') +
         '?id=' + str(sl.id))
     self.assertEqual(response.status_code, 200, response.status_code)
     response = c.logout()
Пример #7
0
    def test_uf_value(self):
        c = Client()
        self.assertTrue(c.login(username='******', password='******'))

        study_dict = {'full_citation': 'foo et al.',
                      'short_citation': 'foo_citation',
                      'summary': 'summary there.'}

        #check to make sure we can create a new study field
        response = c.post(reverse('study:new_study', kwargs={'pk': self.assessment_working.pk}),
            study_dict)
        pk = re.findall(r'/study/(\d+)/$', response['location'])
        pk = int(pk[0])
        self.assertRedirects(response, reverse('study:detail', kwargs={'pk': pk}))

        #check to make sure we can't create a new study citation field that already exists
        response = c.post(reverse('study:new_study', kwargs={'pk': self.assessment_working.pk}),
            study_dict)
        self.assertFormError(response, 'form', None, u'Error- short-citation name must be unique for assessment.')

        #check to make sure we can change an existing study citation field to a different type
        response = c.post(reverse('study:update', kwargs={'pk': pk}),
            study_dict)
        self.assertTrue(response.status_code in [200, 302])
        self.assertTemplateUsed('study/study_detail.html')

        #check to make sure we can create a new study in different assessment
        c.logout()
        self.assertTrue(c.login(username='******', password='******'))

        response = c.post(reverse('study:new_study', kwargs={'pk': self.assessment_final.pk}),
            study_dict)
        pk = re.findall(r'/study/(\d+)/$', response['location'])
        pk = int(pk[0])
        self.assertRedirects(response, reverse('study:detail', kwargs={'pk': pk}))
Пример #8
0
    def test_map_metadata(self):
        """Test that map metadata can be properly rendered
        """
        # first create a map
        c = Client()

        # Test successful new map creation
        c.login(username=self.user, password=self.passwd)
        new_map = reverse('new_map_json')
        response = c.post(new_map, data=self.viewer_config,content_type="text/json")
        self.assertEquals(response.status_code,200)
        map_id = int(json.loads(response.content)['id'])
        c.logout()

        url = reverse('map_metadata', args=(map_id,))

        # test unauthenticated user to modify map metadata
        response = c.post(url)
        self.assertEquals(response.status_code,302)

        # test a user without metadata modify permission
        c.login(username='******', password='******')
        response = c.post(url)
        self.assertEquals(response.status_code, 302)
        c.logout()

        # Now test with a valid user using GET method
        c.login(username=self.user, password=self.passwd)
        response = c.get(url)
        self.assertEquals(response.status_code, 200)

        # Now test with a valid user using POST method
        c.login(username=self.user, password=self.passwd)
        response = c.post(url)
        self.assertEquals(response.status_code, 200)
Пример #9
0
    def test_delete_macrogroup_view(self):
        """
        Testing delete macrogroup
        """

        # Create a macrogroup to delete
        macrogroup_data = {
            'name': 'MacroGroup to delete',
            'title': 'MacroGroup to delete',
            'logo_img': ''
        }
        macrogroup = MacroGroup(**macrogroup_data)
        macrogroup.save()

        # check 1 macrogroup on db
        dbgmacrogropus = MacroGroup.objects.all()
        self.assertEqual(len(dbgmacrogropus), 1)
        self.assertEqual(dbgmacrogropus[0].name, macrogroup_data['name'])

        url = reverse('macrogroup-delete', args=[macrogroup.slug])

        client = Client()
        self.assertTrue(
            client.login(username=self.test_user1.username,
                         password=self.test_user1.username))
        response = client.post(url)

        self.assertEqual(response.status_code, 200)

        # check no macrogroup into db
        dbgmacrogropus = MacroGroup.objects.all()
        self.assertEqual(len(dbgmacrogropus), 0)

        client.logout()
Пример #10
0
    def test_generasuitedata_view(self):
        """ Check GeneralDataSuite view """

        client = Client()

        # Check only admin can access
        # No login: loginrequired return redircte to login page 302
        url = reverse('generaldata-update')

        response = client.get(url)
        self.assertEqual(response.status_code, 302)

        # Check editor level 1
        # Not permission return 403
        self.assertTrue(
            client.login(username=self.test_editor1.username,
                         password=self.test_editor1.username))
        response = client.get(url)
        self.assertEqual(response.status_code, 403)

        client.logout()

        # Check Admin
        # Has access response 200
        self.assertTrue(
            client.login(username=self.test_user1.username,
                         password=self.test_user1.username))
        response = client.get(url)
        self.assertEqual(response.status_code, 200)
Пример #11
0
    def test_delete_group_view(self):
        """
        Testing delete group
        """

        # Create a group to delete
        group_data = {
            'name': 'Group to delete',
            'title': 'Group to delete',
            'header_logo_img': '',
            'srid': G3WSpatialRefSys.objects.get(auth_srid=4326)
        }
        group = Group(**group_data)
        group.save()

        # check 1 group on db
        dbgroups = Group.objects.all()
        self.assertEqual(len(dbgroups), 1)
        self.assertEqual(dbgroups[0].name, group_data['name'])

        url = reverse('group-delete', args=[group.slug])

        client = Client()
        self.assertTrue(
            client.login(username=self.test_user1.username,
                         password=self.test_user1.username))
        response = client.post(url)

        self.assertEqual(response.status_code, 200)

        # check no groups into db
        dbgroups = Group.objects.all()
        self.assertEqual(len(dbgroups), 0)

        client.logout()
Пример #12
0
class AdminTestCase(TestCase):

    def setUp(self):

        self.client = Client()

    def test_admin_login(self):
        # Get login page
        response = self.client.get('/admin/login/')

        # Check response code
        self.assertEquals(response.status_code, 200)


        # Log the user in
        self.client.login(username='******', password="******")
        response = self.client.get('/admin/login/')
        self.assertEquals(response.status_code, 200)

    def test_admin_logout(self):
        # Log in
        self.client.login(username='******', password="******")

        # Check response code
        response = self.client.get('/admin/login/')
        self.assertEquals(response.status_code, 200)

        # Log out
        self.client.logout()

        # Check response code
        response = self.client.get('/admin/')
        self.assertEquals(response.status_code, 302)
Пример #13
0
class TopicTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(username='******',
                                        email='*****@*****.**')
        self.user.set_password('test_password')
        self.user.save()

        self.client = Client()
        self.client.login(username='******', password='******')

    def test_topic_client_login(self):
        topic = Topic.objects.create(name='test_topic', author=self.user)
        response = self.client.get('/topic/{}/detail/'.format(topic.pk))
        self.assertEqual(response.status_code, 200)

    def test_topic_client_logout(self):
        self.client.logout()
        topic = Topic.objects.create(name='test_topic', author=self.user)
        response = self.client.get('/topic/{}/detail/'.format(topic.pk))
        self.assertEqual(response.status_code, 302)

    def test_topic_list_value(self):
        topics = {}
        for i in range(10):
            topics[i] = RandomTopicFactory.create()

        response = self.client.get('/topic/list/')
        content = json.loads(response.content.decode())

        for i in range(10):
            fields = content[i]['fields']
            self.assertEqual(fields['author'], topics[i].author.pk)
            self.assertEqual(fields['name'], topics[i].name)
            self.assertEqual(fields['text'], topics[i].text)
Пример #14
0
class TestDomainViews(TestCase):
    def setUp(self):
        self.client = Client()

        self.domain = Domain(name="fandago", is_active=True)
        self.domain.save()

        self.username = '******'
        self.password = '******'
        self.user = WebUser.create(self.domain.name, self.username, self.password)
        self.user.set_role(self.domain.name, 'admin')
        self.user.save()

    def tearDown(self):
        self.user.delete()
        self.domain.delete()
        
    def test_add_repeater(self):
        forwarding_url = 'https://example.com/forwarding'

        self.client.login(username=self.username, password=self.password)

        post_url = reverse('add_repeater', kwargs={'domain': self.domain.name, 'repeater_type': 'AppStructureRepeater'})
        response = self.client.post(post_url, {'url': forwarding_url}, follow=True)
        self.assertEqual(response.status_code, 200)

        self.client.logout()
        
        app_structure_repeaters = AppStructureRepeater.by_domain(self.domain.name)
        self.assertEqual(len(app_structure_repeaters), 1)

        for app_structure_repeater in app_structure_repeaters:
            app_structure_repeater.delete()
Пример #15
0
class TestDataRetention(TestCase):
    def setUp(self):
        self.c = Client()
        self.user = User.objects.create_user(password='******',
                                             email='*****@*****.**')
        self.c.login(username='******', password='******')

    def tearDown(self):
        self.c.logout()
        User.objects.all().delete()

    def test_data_retention_form(self):
        url = reverse('settings_data')

        response = self.c.post(url, {'check_every': 60, 'keep_data': 30})

        result = data_retention_model.get_one()

        assert result['check_every'] == 60
        assert result['keep_data'] == 30

        response = self.c.post(url, {'check_every': 300, 'keep_data': 60})

        result = data_retention_model.get_one()

        assert result['check_every'] == 300
        assert result['keep_data'] == 60
Пример #16
0
class ViewsTestCase(unittest.TestCase):
    def setUp(self):
        self.client = Client()

    def test_anonymous(self):
        self.client.logout()
        self.client.get('/admin/')
        response = self.client.get('/session_security/ping/?idleFor=1')
        self.assertEqual(response.content, 'logout')

    ping_provider = lambda: (
        (1, 4, '1'),
        (3, 2, '2'),
        (5, 5, '5'),
        (12, 14, 'logout', False),
    )

    @data_provider(ping_provider)
    def test_ping(self, server, client, expected, authenticated=True):
        self.client.login(username='******', password='******')
        self.client.get('/admin/')

        now = datetime.now()
        session = self.client.session
        session['_session_security'] = now - timedelta(seconds=server)
        session.save()
        response = self.client.get('/session_security/ping/?idleFor=%s' %
                                   client)

        self.assertEqual(response.content, expected)
        self.assertEqual(authenticated, '_auth_user_id' in self.client.session)
Пример #17
0
class ViewsTestCase(unittest.TestCase):
    def setUp(self):
        self.client = Client()

    def test_anonymous(self):
        self.client.logout()
        self.client.get('/admin/')
        response = self.client.get('/session_security/ping/?idleFor=1')
        self.assertEqual(response.content, six.b('logout'))

    ping_provider = lambda x=None: (
        (1, 4, '1'),
        (3, 2, '2'),
        (5, 5, '5'),
        (12, 14, 'logout', False),
    )

    @data_provider(ping_provider)
    def test_ping(self, server, client, expected, authenticated=True):
        self.client.login(username='******', password='******')
        self.client.get('/admin/')

        now = datetime.now()
        session = self.client.session
        set_last_activity(session, now - timedelta(seconds=server))
        session.save()
        response = self.client.get('/session_security/ping/?idleFor=%s' %
                                   client)

        self.assertEqual(response.content, six.b(expected))
        self.assertEqual(authenticated, '_auth_user_id' in self.client.session)
Пример #18
0
class TestNotifications(TestCase):
    def setUp(self):
        self.c = Client()
        self.user = User.objects.create_user(password='******',
                                             email='*****@*****.**')

        self.c.login(username='******', password='******')

    def tearDown(self):
        self.c.logout()
        self.user.delete()
        notifications_model.collection.remove()

    def _cleanup(self):
        notifications_model.collection.remove()

    def test_add_url(self):

        self._cleanup()

        url = reverse('notifications_add', kwargs={"provider_id": "pushover"})

        response = self.c.post(
            url, {
                'name': 'default',
                'user_key': 'somekey',
                'application_api_key': 'some'
            })

        self.assertRedirects(
            response,
            reverse('notifications_edit', kwargs={'provider_id': 'pushover'}))
        assert notifications_model.collection.find().count() == 1

        result = notifications_model.collection.find_one()

        edit_url = reverse('notifications_edit',
                           kwargs={
                               "provider_id": "pushover",
                               'notification_id': result['_id']
                           })
        response = self.c.post(
            edit_url, {
                'name': 'default',
                'user_key': 'changed_user_key',
                'application_api_key': 'changed_data'
            })

        self.assertRedirects(
            response,
            reverse('notifications_edit',
                    kwargs={
                        'provider_id': 'pushover',
                        'notification_id': result['_id']
                    }))
        assert notifications_model.collection.find().count() == 1

        for r in notifications_model.collection.find():
            assert r['application_api_key'] == 'changed_data'
            assert r['user_key'] == 'changed_user_key'
Пример #19
0
class TestModels(TestCase):

    def setUp(self):
        """Set up the client."""
        self.c = Client()
        self.user = User.objects.create_user('john', '*****@*****.**', 'password')
        self.user.save()
        self.c.login(username='******', password='******')
        session = self.c.session
        session.save()
        re = 'test'
        Group.objects.get_or_create(name=re)
        grp_obj = Group.objects.get(name=re)
        grp_obj.user_set.add(self.user)

    def test_wod_index_context(self):
        response = self.c.get(reverse('wod_index'), follow=True)
        self.assertTrue(response.status_code == 200)
        self.assertTrue("latest_wod_list" in response.context)
        self.assertTrue("request" in response.context)
        self.assertTrue("user" in response.context)
        self.assertTrue("messages" in response.context)
        self.assertTemplateUsed(response, "wod/wod_archive.html")

    def test_wod_details_context(self):
        response = self.c.get(reverse('wod_index'), follow=True)
        self.assertTrue(response.status_code == 200)
        self.assertTemplateUsed(response, "wod/wod_archive.html")
        management.call_command('load_data')
        response = self.c.get(reverse('wod_index'), follow=True)
        self.assertTrue(len(response.context['latest_wod_list'])!= 0)
        response = self.c.get(reverse('wod_details', kwargs={
                                                            'wod_id': 1,
                                                            }), follow=True)
        self.assertTrue(response.status_code == 200)
        self.assertTemplateUsed(response, "wod/wod_page.html")
        self.assertContains(response, "<p>Wod page</p>")
        self.assertContains(response, "Logout")

    def test_home_context(self):
        response = self.c.get('/home/')
        self.assertTrue(response.status_code == 200)
        self.assertTrue("request" in response.context)
        self.assertTrue("user" in response.context)
        self.assertTrue("messages" in response.context)

    def test_user_home_logout(self):
        self.c.logout()
        response = self.c.get('/home/')
        self.assertTrue(response.status_code == 200)
        self.assertContains(response, 'login')
        self.assertContains(response, 'register')

    def test_intruder(self):
        self.c.logout()
        response = self.c.get(reverse('wod_index'))
        self.assertTrue(response.status_code == 302)
        self.c.login(username='******', password='******')
        response = self.c.get(reverse('wod_index'), follow=True)
        self.assertTrue(response.status_code == 200)
Пример #20
0
    def test_votes_view(self):
        client = Client()
        submission = Submission.objects.create(artwork=self.artwork, exhibition=self.exhibition, submitted_by=self.user)
        vote = Vote.objects.create(submission=submission, status=Vote.THUMBS_UP, voted_by=self.user)

        # anonymous users don't see others' votes, just the score
        view_url = reverse("submission-view", kwargs={"pk": submission.id})
        response = client.get(view_url)
        self.assertEqual(response.status_code, 200)
        self.assertTrue("share_url" in response.context)
        self.assertEquals(response.context["votes"], {})
        self.assertEquals(response.context["submission"].score, 1)

        # logged-in users see own votes
        logged_in = client.login(username=self.get_username(), password=self.get_password())
        self.assertTrue(logged_in)
        view_url = reverse("submission-view", kwargs={"pk": submission.id})
        response = client.get(view_url)
        self.assertEqual(response.status_code, 200)
        self.assertTrue("share_url" in response.context)
        self.assertEquals(response.context["votes"], {submission.id: vote})
        self.assertEquals(response.context["submission"].score, 1)

        client.logout()
        logged_in = client.login(username=self.get_username("staff"), password=self.get_password("staff"))
        self.assertTrue(logged_in)
        view_url = reverse("submission-view", kwargs={"pk": submission.id})
        response = client.get(view_url)
        self.assertEqual(response.status_code, 200)
        self.assertTrue("share_url" in response.context)
        self.assertEquals(response.context["votes"], {})
        self.assertEquals(response.context["submission"].score, 1)
Пример #21
0
class AdminViewsTestCase(unittest.TestCase):
    '''
    Testing admin views class
    '''

    def setUp(self):
        '''
        Command run before every test
        '''
        self.u1 = User.objects.create(username='******', email='*****@*****.**',
                                      is_staff=True, is_superuser=True)
        self.u1.set_password('test')
        self.u1.save()
        self.c1 = Client()
        self.assertTrue(self.c1.login(username='******', password='******'))
        self.key1 = Key.objects.create(name='Key1')

    def tearDown(self):
        '''
        Command run after every test
        '''
        self.key1.delete()
        self.c1.logout()
        User.objects.all().delete()

    def test_admin_keyvalue(self):
        response = self.c1.get('/admin/keyvalue/key/')
        self.assertEqual(response.status_code, 200)

    def test_admin_keyvalue1(self):
        response = self.c1.get('/admin/keyvalue/key/%s/' % self.key1.id)
        self.assertEqual(response.status_code, 200)
Пример #22
0
class TestPhotosetCreationDeletion(unittest.TestCase):
	"""Tests the ability to create and delete PhotoSets."""
	
	def setUp(self):
		"""Creates two user accounts and a web client."""
		self.alice = User.objects.create_user('alice', '*****@*****.**', password='******')
		self.bob = User.objects.create_user('bob', '*****@*****.**', password='******')
		self.alice_client = Client()
		self.bob_client = Client()
		self.alice_client.login(username='******', password='******')
		self.bob_client.login(username='******', password='******')
	
	def tearDown(self):
		"""Deletes the two user accounts."""
		self.alice_client.logout()
		self.bob_client.logout()
		self.alice.delete()
		self.bob.delete()
	
	def testCreationDeletion(self):
		"""Checks that Alice can login and create and delete a PhotoSet."""
		# check that the photoset does not exist yet
		self.assertEqual(PhotoSet.objects.filter(slug='alices-photos').count(), 0)
		# create a photoset
		response = self.alice_client.post(reverse('clickclick.create_photoset'), {'title': 'Alice\'s Photos', 'slug': 'alices-photos', })
		# check that it exists
		self.assertEqual(PhotoSet.objects.filter(slug='alices-photos').count(), 1)
		# attempt to delete the photoset as bob
		response = self.bob_client.post(reverse('clickclick.delete_photoset', args=['alices-photos',]))
		# check that the photoset still exists (i.e., deletion failed)
		self.assertEqual(PhotoSet.objects.filter(slug='alices-photos').count(), 1)
		# delete the photoset as alice
		response = self.alice_client.post(reverse('clickclick.delete_photoset', args=['alices-photos',]))
		# check that it no longer still exists
		self.assertEqual(PhotoSet.objects.filter(slug='alices-photos').count(), 0)
Пример #23
0
class AlertTest(TestCase):
    fixtures = ['test_court.json', 'authtest_data.json']

    def setUp(self):
        # Set up some handy variables
        self.client = Client()
        self.alert_params = {
            'query': 'q=asdf',
            'name': 'dummy alert',
            'rate': 'dly',
            'always_send_email': 'on',
        }

    def test_create_alert(self):
        """Can we create an alert by sending a post?"""
        self.client.login(username='******', password='******')
        r = self.client.post('/', self.alert_params, follow=True)
        self.assertEqual(r.redirect_chain[0][1], 302)
        self.assertIn('successfully', r.content)
        self.client.logout()

    def test_fail_gracefully(self):
        """Do we fail gracefully when an invalid alert form is sent?"""
        # Use a copy to shield other tests from changes.
        bad_alert_params = self.alert_params.copy()
        # Break the form
        bad_alert_params.pop('query', None)
        self.client.login(username='******', password='******')
        r = self.client.post('/', bad_alert_params, follow=True)
        self.assertEqual(r.status_code, 200)
        self.assertIn('error creating your alert', r.content)
        self.client.logout()
Пример #24
0
    def test_map_save(self):
        """POST /maps -> Test saving a new map"""

        c = Client()

        # Test that saving a map when not logged in gives 401
        response = c.post("/maps/",
                          data=MapTest.viewer_config,
                          content_type="text/json")
        self.assertEqual(response.status_code, 401)

        # Test successful new map creation
        log = c.login(username="******", password="******")
        response = c.post("/maps/",
                          data=MapTest.viewer_config,
                          content_type="text/json")
        self.assertEquals(response.status_code, 201)
        map_id = int(response['Location'].split('/')[-1])
        c.logout()

        self.assertEquals(map_id, 2)
        map = Map.objects.get(id=map_id)
        self.assertEquals(map.title, "Title")
        self.assertEquals(map.abstract, "Abstract")
        self.assertEquals(map.layer_set.all().count(), 1)

        # Test an invalid map creation request
        log = c.login(username="******", password="******")
        response = c.post("/maps/",
                          data="not a valid viewer config",
                          content_type="text/json")
        self.assertEquals(response.status_code, 400)
        c.logout()
Пример #25
0
class Spot1303(TestCase):
    def test_change_ownership(self):
        creators, created = Group.objects.get_or_create(name="spacescout_creators")
        admins, created = Group.objects.get_or_create(name="spacescout_admins")

        admin_user = User.objects.create_user("admin_user", "*****@*****.**", "ok")
        admins.user_set.add(admin_user)

        creator_user1 = User.objects.create_user("creator_user1", "*****@*****.**", "ok")
        creators.user_set.add(creator_user1)
        creator_user2 = User.objects.create_user("creator_user2", "*****@*****.**", "ok")
        creators.user_set.add(creator_user2)


        # Create the space as a creator user
        self.client = Client()
        self.client.login(username="******", password="******")
        response = self.client.post("/api/v1/space/", '{ "name": "test_space", "manager": "creator_user1" }', content_type="application/json")
        data = json.loads(response.content)

        url = "/api/v1/space/%s/" % data["id"]
        pk = int(data["id"])
        space = Space.objects.get(pk = pk)
        self.assertEqual(space.manager, "creator_user1")

        # As an admin, change the manager

        self.client.logout()
        self.client.login(username="******", password="******")
        response = self.client.put(url, '{ "manager": "creator_user2" }', content_type="application/json")

        space = Space.objects.get(pk = pk)

        self.assertEqual(space.manager, "creator_user2")
Пример #26
0
 def test_optional_email_verification(self):
     c = Client()
     # Signup
     c.get(reverse("account_signup"))
     resp = c.post(
         reverse("account_signup"),
         {"username": "******", "email": "*****@*****.**", "password1": "johndoe", "password2": "johndoe"},
     )
     # Logged in
     self.assertEqual(resp["location"], "http://testserver" + settings.LOGIN_REDIRECT_URL)
     self.assertEqual(resp.status_code, 302)
     self.assertEqual(mail.outbox[0].to, ["*****@*****.**"])
     self.assertEqual(len(mail.outbox), 1)
     # Logout & login again
     c.logout()
     # Wait for cooldown
     EmailConfirmation.objects.update(sent=now() - timedelta(days=1))
     # Signup
     resp = c.post(reverse("account_login"), {"login": "******", "password": "******"})
     self.assertEqual(resp.status_code, 302)
     self.assertEqual(resp["location"], "http://testserver" + settings.LOGIN_REDIRECT_URL)
     self.assertEqual(mail.outbox[0].to, ["*****@*****.**"])
     # There was an issue that we sent out email confirmation mails
     # on each login in case of optional verification. Make sure
     # this is not the case:
     self.assertEqual(len(mail.outbox), 1)
Пример #27
0
class AlertTest(TestCase):
    fixtures = ['test_court.json', 'authtest_data.json']

    def setUp(self):
        # Set up some handy variables
        self.client = Client()
        self.alert_params = {
            'alertText': 'q=asdf',
            'alertName': 'dummy alert',
            'alertFrequency': 'dly',
            'sendNegativeAlert': 'on',
        }

    def test_create_alert(self):
        """Can we create an alert by sending a post?"""
        self.client.login(username='******', password='******')
        r = self.client.post('/', self.alert_params, follow=True)
        self.assertEqual(r.redirect_chain[0][1], 302)
        self.assertIn('successfully', r.content)
        self.client.logout()

    def test_fail_gracefully(self):
        """Do we fail gracefully when an invalid alert form is sent?"""
        # Use a copy to shield other tests from changes.
        bad_alert_params = self.alert_params.copy()
        # Break the form
        bad_alert_params.pop('alertText', None)
        self.client.login(username='******', password='******')
        r = self.client.post('/', bad_alert_params, follow=True)
        self.assertEqual(r.status_code, 200)
        self.assertIn('error creating your alert', r.content)
        self.client.logout()
Пример #28
0
class TestUserAdmin(TransactionTestCase):
    fixtures = ['init_panda.json', 'test_users.json']

    def setUp(self):
        self.user = utils.get_panda_user()

        self.client = Client()
        self.client.login(username='******', password='******')

    def tearDown(self):
        self.client.logout()

    def test_add_user(self):
        # Test fetching the form
        response = self.client.get(reverse('admin:panda_userproxy_add'))

        self.assertEqual(response.status_code, 200)

        new_user = {'email': '*****@*****.**', 'last_name': 'Barman'}

        # Test submitting the form
        response = self.client.post(reverse('admin:panda_userproxy_add'),
                                    new_user)

        self.assertEqual(response.status_code, 302)

        created_user = UserProxy.objects.get(username='******')
        self.assertEqual(created_user.last_name, 'Barman')
Пример #29
0
class ViewsTestCase(unittest.TestCase):
    def setUp(self):
        get_or_create_test_admin()
        self.client = Client()

    def test_anonymous(self):
        self.client.logout()
        self.client.get("/admin/")
        response = self.client.get("/session_security/ping/?idleFor=1")
        self.assertEqual(response.content, six.b("logout"))

    ping_provider = lambda x=None: ((1, 4, "1"), (3, 2, "2"), (5, 5, "5"), (12, 14, "logout", False))

    @data_provider(ping_provider)
    def test_ping(self, server, client, expected, authenticated=True):
        self.client.login(username="******", password="******")
        self.client.get("/admin/")

        now = datetime.now()
        session = self.client.session
        set_last_activity(session, now - timedelta(seconds=server))
        session.save()
        response = self.client.get("/session_security/ping/?idleFor=%s" % client)

        self.assertEqual(response.content, six.b(expected))
        self.assertEqual(authenticated, "_auth_user_id" in self.client.session)
Пример #30
0
    def test_favorite_departments_list_view(self):
        """
        Tests the favorite departments list view.
        """
        fd1 = FireDepartment.objects.create(name='Fire Department 1')
        fd2 = FireDepartment.objects.create(name='Fire Department 2')
        fd3 = FireDepartment.objects.create(name='Fire Department 3')
        # add these departments as favorites and remove the last one
        user = User.objects.get(username='******')
        Favorite.objects.create(user, fd1)
        Favorite.objects.create(user, fd2)
        fav = Favorite.objects.create(user, fd3)
        fav.delete()

        c = Client()
        c.login(**{'username': '******', 'password': '******'})

        response = c.get(reverse('firedepartment_list') + '?favorites=true')
        self.assertTrue(fd1 in response.context['object_list'])
        self.assertTrue(fd2 in response.context['object_list'])
        self.assertTrue(fd3 not in response.context['object_list'])
        self.assertEqual(response.status_code, 200)

        c.logout()

        try:
            response = c.get(
                reverse('firedepartment_list') + '?favorites=true')
        except:
            self.fail(
                'Logged-out user triggering favorites search should not throw exception'
            )
Пример #31
0
class TestBookmarks(TestCase):
    def setUp(self):
        self.c = Client()
        self.user = User.objects.create_user(password='******',
                                             email='*****@*****.**')

        self.c.login(username='******', password='******')

    def tearDown(self):
        self.c.logout()
        self.user.delete()

    def _cleanup(self):
        tags_model.collection.remove()
        tag_groups_model.collection.remove()
        bookmarks_model.collection.remove()

    def add_delete_bookmark_test(self):
        self._cleanup()

        url = reverse('bookmarks_add')
        tags = {'provider': 'digitalocean', 'credentials': 'production'}

        tag_ids = [str(x) for x in tags_model.create_and_return_ids(tags)]
        tag_ids_str = ",".join(tag_ids)

        form_data = {'name': 'test', 'tags': tag_ids_str, 'type': 'server'}

        response = self.c.post(url, form_data)

        assert response.status_code == 302
        assert bookmarks_model.collection.find().count() == 1
Пример #32
0
    def test_proxy_url(self):
        no_signals()
        c = Client()
        response = c.post('/media/proxy/create/')
        # Response is JSON, should always be 200
        self.assertEqual(200, response.status_code)
        # Result should be error since we did not provide any credentials
        data = json.loads(response.content)
        self.assertEqual('error', data['result'])

        login = c.login(username='******', password='******')
        self.assertTrue(login)

        TrustedSubnet.objects.create(subnet='127.0.0.1')

        response = c.post('/media/proxy/create/',
                          {'url': self.record.get_thumbnail_url(), 'context': '_1_2'},
                          HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        self.assertEqual(200, response.status_code)
        data = json.loads(response.content)
        self.assertEqual('ok', data['result'])
        id = data['id']
        c.logout()

        # try to retrieve content
        url = '/media/proxy/%s/' % id
        response = c.get(url, {'context': '_1_2'})
        self.assertEqual(200, response.status_code)
        self.assertEqual('image/jpeg', response['content-type'])

        # make sure image dimension restrictions took effect
        image = Image.open(StringIO(response.content))
        width, height = image.size
        self.assertEqual(50, width)
Пример #33
0
class BaseTest(TestCase):

    fixtures = [
        os.path.join(settings.ROOT, "survey", "tests", "testdump.json")
    ]

    def setUp(self):
        user = User(username=settings.DEBUG_ADMIN_NAME,
                    is_superuser=True,
                    is_staff=True)
        user.set_password(settings.DEBUG_ADMIN_PASSWORD)
        user.save()
        self.client = Client()

    def tearDown(self):
        self.logout()

    def login(self):
        """ Log the user in. """
        is_logged = self.client.login(username=settings.DEBUG_ADMIN_NAME,
                                      password=settings.DEBUG_ADMIN_PASSWORD)
        if not is_logged:  # pragma: no cover
            raise Exception("Login failed for test user! Tests won't work.")

    def logout(self):
        """ Log the user out. """
        self.client.logout()
Пример #34
0
    def test_map_save(self):
        """POST /maps/new/data -> Test saving a new map"""

        c = Client()
        new_map = reverse("new_map_json")
        # Test that saving a map when not logged in gives 401
        response = c.post(new_map,data=self.viewer_config,content_type="text/json")
        self.assertEqual(response.status_code,401)

        # Test successful new map creation
        c.login(username=self.user, password=self.passwd)
        response = c.post(new_map,data=self.viewer_config,content_type="text/json")
        self.assertEquals(response.status_code,200)
        map_id = int(json.loads(response.content)['id'])
        c.logout()

        # We have now 9 maps and 8 layers so the next pk will be 18
        self.assertEquals(map_id,18)
        map_obj = Map.objects.get(id=map_id)
        self.assertEquals(map_obj.title, "Title")
        self.assertEquals(map_obj.abstract, "Abstract")
        self.assertEquals(map_obj.layer_set.all().count(), 1)
        self.assertEquals(map_obj.keyword_list(), [u"keywords", u"saving"])

        # Test an invalid map creation request
        c.login(username=self.user, password=self.passwd)
        response = c.post(new_map,data="not a valid viewer config",content_type="text/json")
        self.assertEquals(response.status_code,400)
        c.logout()
Пример #35
0
    def test_maps_search(self):
        """Test maps search can function properly
        """
        # first create two maps
        c = Client()

        # Test successful new map creation
        c.login(username=self.user, password=self.passwd)

        new_map = reverse('new_map_json')
        response = c.post(new_map, data=self.viewer_config,content_type="text/json")
        self.assertEquals(response.status_code,200)
        map_id = int(json.loads(response.content)['id'])
        response = c.post(new_map, data=self.viewer_config_alternative,content_type="text/json")
        self.assertEquals(response.status_code,200)
        map_id_2 = int(json.loads(response.content)['id'])
        c.logout()

        url = reverse('maps_search_api') + '?'

        # Test GET method
        response = c.get(url, {'q': '', 'start': 1}, content_type="text/json")
        self.assertEquals(response.status_code,200)
        response_dict = json.loads(response.content)
        self.assertEquals(response_dict['success'], True)

        # Test POST method
        response = c.post(url, {'q': '', 'start': 1}, content_type="text/json")
        self.assertEquals(response.status_code,200)
        response_dict = json.loads(response.content)
        self.assertEquals(response_dict['success'], True)

        # Test methods other than GET or POST
        response = c.put(url)
        self.assertEquals(response.status_code,405)
Пример #36
0
 def test_optional_email_verification(self):
     c = Client()
     # Signup
     resp = c.post(
         reverse('account_signup'), {
             'username': '******',
             'email': '*****@*****.**',
             'password1': 'johndoe',
             'password2': 'johndoe'
         })
     # Logged in
     self.assertEqual(resp['location'],
                      'http://testserver' + settings.LOGIN_REDIRECT_URL)
     self.assertEqual(resp.status_code, 302)
     self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
     self.assertEqual(len(mail.outbox), 1)
     # Logout & login again
     c.logout()
     # Wait for cooldown
     EmailConfirmation.objects.update(sent=now() - timedelta(days=1))
     # Signup
     resp = c.post(reverse('account_login'), {
         'login': '******',
         'password': '******'
     })
     self.assertEqual(resp.status_code, 302)
     self.assertEqual(resp['location'],
                      'http://testserver' + settings.LOGIN_REDIRECT_URL)
     self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
     # There was an issue that we sent out email confirmation mails
     # on each login in case of optional verification. Make sure
     # this is not the case:
     self.assertEqual(len(mail.outbox), 1)
Пример #37
0
class AdminTestCase(TestCase):
    def setUp(self):
        self.admin = User.objects.create_superuser('admin', '*****@*****.**',
                                                   'test1234')
        self.client = Client()

    def test_admin_login(self):
        # Get login page
        response = self.client.get('/admin/login/')

        # Check response code
        self.assertEquals(response.status_code, 200)

        # Log the admin in
        self.client.post('/admin/login/')
        self.client.login(username='******', password="******")
        response = self.client.post('/admin/login/')
        self.assertEquals(response.status_code, 200)

    def test_admin_logout(self):
        # Log in
        self.client.login(username='******', password="******")

        # Check response code
        response = self.client.get('/admin/login/')
        self.assertEquals(response.status_code, 200)

        # Log out
        self.client.logout()

        # Check response code
        response = self.client.get('/admin/')
        self.assertEquals(response.status_code, 302)
Пример #38
0
class TokenuserDeniedAccessTestCase(TestCase):

    def setUp(self):

        self.accounts = [('user1', 'pwd1', 'useronefirstname', 'useronelastname'),
                         ('user2', 'pwd2', 'usertwofirstname', 'usertwolastname'),
                         ('user3', 'pwd3', 'userthreefirstname', 'userthreelastname')]

        self.token_accounts = [(settings.TOKEN_USERNAME, '', 'Token', 'User')]

        self.accounts += self.token_accounts

        for (uname, pwd, first, last) in self.accounts:
            user = User.objects.create_user(uname, '', pwd)
            user.first_name = first
            user.last_name = last
            user.save()
            profile = UserProfile(user=user,
                                         isDjangoAccount=True)
            profile.save()
        self.users = User.objects.all()

        self.client = Client()
        login = self.client.login(username=self.accounts[0][0],
                                  password=self.accounts[0][1])
        self.assertTrue(login)

    def testGetUserList(self):

        # Match all
        response = self.client.get('/ajax/user_list/?q=')
        self.assertEqual(response.status_code, 200)
        users_dict = json.loads(response.content)
        self.assertEqual(len(self.users) - len(self.token_accounts), len(users_dict))
        for user in self.users:
            user_info = [ u for u in users_dict if u['username'] == user.username ]
            if user.username == settings.TOKEN_USERNAME:
                self.assertEqual([], user_info)
            else:
                self.assertEqual(1, len(user_info))
                self.assertEqual(user_info[0]['first_name'], user.first_name)
                self.assertEqual(user_info[0]['last_name'], user.last_name)


        # Match on first name
        response = self.client.get('/ajax/user_list/?q=token')
        self.assertEqual(response.status_code, 200)
        users_dict = json.loads(response.content)

        self.assertEqual(0, len(users_dict))

        # Match on last name
        response = self.client.get('/ajax/user_list/?q=user')
        self.assertEqual(response.status_code, 200)
        users_dict = json.loads(response.content)

        self.assertEqual(len(self.users) - len(self.token_accounts), len(users_dict))

    def tearDown(self):
        self.client.logout()
Пример #39
0
    def test_flag(self):
        self.q.flagged()
        self.assertEquals(self.q.flags_count, 1)
        c = Client()
        response = c.post(reverse('flag_question', kwargs={'q_id':self.q.id}))
        self.assertEquals(response.status_code, 200)
        data = json.loads(response.content)
        self.assertIn('redirect', data)
        respone = c.post(data['redirect'],
                {'username':"******", 'password':"******"})
        response = c.post(reverse('flag_question', kwargs={'q_id':self.q.id}))
        data = json.loads(response.content)
        self.assertIn('message', data)
        self.assertEquals(data['message'], 'Thank you for flagging the question. One of our editors will look at it shortly.')
        self.q = Question.objects.get(pk=self.q.id)
        self.assertEquals(self.q.flags_count, 2)
        response = c.get(reverse('home')+"?filter=flagged")
        self.assertEquals(response.context['questions'].count(), 1)

        response = c.post(reverse('flag_question', kwargs={'q_id':self.q.id}))
        data = json.loads(response.content)
        self.assertIn('message', data)
        self.assertEquals(data['message'], 'Thanks.  You already reported this question')
        c.logout()
        self.assertTrue(c.login(username="******", password="******"))
        response = c.post(reverse('flag_question', kwargs={'q_id':self.q.id}))
        data = json.loads(response.content)
        self.assertIn('redirect', data)
        self.assertEquals(data['redirect'], reverse('qna', args=(self.q.entity.slug, )))
Пример #40
0
    def test_ssl_redirect_by_proxy(self):
        users.get_user_from_request = self._real_get_user_from_request
        dogs = horizon.get_dashboard("dogs")
        puppies = dogs.get_panel("puppies")
        url = puppies.get_absolute_url()
        redirect_url = "?".join(
            [urlresolvers.reverse("horizon:auth_login"),
             "next=%s" % url])

        client = Client()
        client.logout()
        resp = client.get(url)
        self.assertRedirectsNoFollow(resp, redirect_url)

        # Set SSL settings for test server
        settings.TESTSERVER = 'https://testserver:80'
        settings.SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTOCOL',
                                            'https')

        resp = client.get(url, HTTP_X_FORWARDED_PROTOCOL="https")
        self.assertRedirectsNoFollow(resp, redirect_url)

        # Restore settings
        settings.TESTSERVER = 'http://testserver'
        settings.SECURE_PROXY_SSL_HEADER = None
Пример #41
0
class ServerTestCases(TestCase):
    #fixtures = ['serverTestFixtures.json']
    loginURL = '/login/'
    client = Client()
    STATUS_OK = 200
    existingUser = {'id':'id', 'password':'******'}
    user = User.objects.create_user(existingUser['id'], '*****@*****.**', existingUser['password'])
    
    def setUp(self):
        self.client = Client()
        self.assertTrue(self.login())

    def test_loginPage(self):
        response = self.client.get('/login/')
        self.assertEquals(response.status_code, self.STATUS_OK)

    def test_redirect_loggedIn(self):
        response = self.client.get('', follow=True)
        self.assertTrue(len(response.redirect_chain) == 0)

    def test_redirect_loggedOut(self):
        self.client.logout()
        response = self.client.get('', follow=True)
        self.assertTrue(len(response.redirect_chain) == 1)
        redirect = response.redirect_chain[0]
        self.assertIn('/login/?next=/', redirect[0])
        self.assertEquals(302, redirect[1])

    def login(self):
        return self.client.login(username=self.existingUser['id'], password=self.existingUser['password'])
Пример #42
0
class ChatPageTest(TestCase):
    """Test the chat test page."""

    # This includes a sample room.
    fixtures = ['test_jqchat.json']

    def setUp(self):
        self.client = Client()
        self.client.login(username='******', password='******')

    def test_chat_page(self):
        """We have a basic test page for the chat client."""

        # Get the room defined in the fixture.
        response = self.client.get('/jqchat/room/1/')
        self.assert_(response.status_code == 200, response.status_code)

        # Basic checks on the content of this page.
        self.assert_('<div id="chatwindow">' in response.content)
        self.assert_(response.context[0]['room'].name == 'The first room', response.context[0]['room'])

    def test_login(self):
        """Must be logged in to access the chat page."""

        self.client.logout()
        response = self.client.get('/jqchat/room/1/')
        # Should redirect to login page.
        self.assert_(response.status_code == 302, response.status_code)
Пример #43
0
    def test_lot_login_view_allways_valid(self):
        c = Client()
        lots = LOT.objects.all().count()

        response = c.get('/login/{0}/'.format(self.lot3.uuid))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(c.session['_auth_user_id'], 1)

        c.logout()
        self.assertFalse("_auth_user_id" in c.session)

        self.assertEqual(LOT.objects.all().count(), lots)

        response = c.get('/login/{0}/'.format(self.lot3.uuid))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(c.session['_auth_user_id'], 1)

        c.logout()
        self.assertFalse("_auth_user_id" in c.session)

        self.assertEqual(LOT.objects.all().count(), lots)

        self.lot3.created = self.lot3.created - datetime.timedelta(days=10000)
        self.lot3.save(force_modification=True)

        response = c.get('/login/{0}/'.format(self.lot3.uuid))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(c.session['_auth_user_id'], 1)

        self.assertEqual(LOT.objects.all().count(), lots)
Пример #44
0
class TestAlbumView(TestCase):
    """Test the album view.
    The album view displays the title of the album, its description, and
    thumbnails of all photos in the album.
    """
    fixtures = ['test_auth.json', 'test_photo_manager.json']

    def setUp(self):
        self.client = Client()
        self.client.login(username='******', password='******')
        self.url = "/pm/album/{}"
        self.login_redirect = "/account/login/?next={}".format(self.url)

    def test_album_view(self):
        """Test that the album view appears as expected."""
        album = Album.objects.get(title="Test Album")
        response = self.client.get(self.url.format(album.pk))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed('PhotoManager/album.html')

    def test_album_view_not_logged_in(self):
        """Try to access the album view when not logged in and assert that
        we are redirected to the login view.
        """
        self.client.logout()
        album = Album.objects.get(title="Test Album")
        response = self.client.get(self.url.format(album.pk))
        self.assertRedirects(response, self.login_redirect.format(album.pk))

    def test_album_view_wrong_user(self):
        """Attempt to access an album from a user account that the album
        doesn't belong to.
        """
        self.client.logout()
        self.client.login(username='******', password='******')
        album = Album.objects.get(title="Test Album")
        response = self.client.get(self.url.format(album.pk))
        self.assertEqual(response.status_code, 403)
        self.assertIn('403 Forbidden', response.content)

    def test_album_view_no_photos(self):
        """Verify that an album containing no photos still displays
        title and description.
        """
        album = Album.objects.get(title="Test Album")
        response = self.client.get(self.url.format(album.pk))
        self.assertEqual(response.status_code, 200)
        self.assertIn(album.title, response.content)
        self.assertIn(album.description, response.content)

    def test_album_view_with_photos(self):
        """Verify that an album containing photos shows title, description,
        and thumbnails.
        """
        album = Album.objects.get(title="Another Test Album")
        response = self.client.get(self.url.format(album.pk))
        self.assertEqual(response.status_code, 200)
        self.assertIn(album.title, response.content)
        self.assertIn(album.description, response.content)
        self.assertIn('img', response.content)
Пример #45
0
    def test_lot_login_middleware_always_valid(self):
        c = Client()
        lots = LOT.objects.all().count()

        response = c.get('/test_url/', {'uuid-login': self.lot3.uuid})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(c.session['_auth_user_id'], 1)

        c.logout()
        self.assertFalse("_auth_user_id" in c.session)

        self.assertEqual(LOT.objects.all().count(), lots)

        response = c.get('/test_url/', {'uuid-login': self.lot3.uuid})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(c.session['_auth_user_id'], 1)

        c.logout()
        self.assertFalse("_auth_user_id" in c.session)

        self.assertEqual(LOT.objects.all().count(), lots)

        self.lot3.created = self.lot3.created - datetime.timedelta(days=10000)
        self.lot3.save(force_modification=True)

        response = c.get('/test_url/', {'uuid-login': self.lot3.uuid})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(c.session['_auth_user_id'], 1)

        self.assertEqual(LOT.objects.all().count(), lots)
Пример #46
0
class UserChangePwdTest(TestCase):
    def setUp(self):
        self.user = User(username="******")
        self.user.set_password("111111")
        self.user.save()
        self.client = Client()
        self.client.login(username="******", password="******")

    def test_change_pwd_with_correct_info(self):
        self.client.login(username="******", password="******")
        response = self.client.post(reverse("change_password"), {"old_password": "******",
                                                                 "password1": "123456",
                                                                 "password2": "123456"})
        self.assertEqual(json.loads(response.content)["status"], "success")

    def test_change_pwd_without_login(self):
        self.client.logout()
        response = self.client.post(reverse("change_password"), {"old_password": "******",
                                                                 "password1": "123456",
                                                                 "password2": "123456"})
        self.assertRedirects(response, reverse("login") + '?next=/account/change_password/')

    def test_change_pwd_with_error_old_pwd(self):
        self.client.login(username="******", password="******")
        response = self.client.post(reverse("change_password"), {"old_password": "******",
                                                                 "password1": "123456",
                                                                 "password2": "123456"})
        self.assertEqual(json.loads(response.content)["status"], "error")

    def test_change_pwd_with_different_new_pwd(self):
        self.client.login(username="******", password="******")
        response = self.client.post(reverse("change_password"), {"old_password": "******",
                                                                 "password1": "123456",
                                                                 "password2": "123453"})
        self.assertEqual(json.loads(response.content)["status"], "error")
class AdminViewsTestCase(unittest.TestCase):
    '''
    Testing admin views class
    '''
    def setUp(self):
        '''
        Command run before every test
        '''
        self.u1 = User.objects.create(username='******',
                                      email='*****@*****.**',
                                      is_staff=True,
                                      is_superuser=True)
        self.u1.set_password('test')
        self.u1.save()
        self.c1 = Client()
        self.assertTrue(self.c1.login(username='******', password='******'))
        self.key1 = Key.objects.create(name='Key1')

    def tearDown(self):
        '''
        Command run after every test
        '''
        self.key1.delete()
        self.c1.logout()
        User.objects.all().delete()

    def test_admin_keyvalue(self):
        response = self.c1.get('/admin/keyvalue/key/')
        self.assertEqual(response.status_code, 200)

    def test_admin_keyvalue1(self):
        response = self.c1.get('/admin/keyvalue/key/%s/' % self.key1.id)
        self.assertEqual(response.status_code, 200)
Пример #48
0
class TestBase(TestCase):

    def _create_user(self):
        user = User.objects.create_user('admin', '*****@*****.**', '123')
        return user

    def login(self, username='******', password='******'):
        self._create_user()
        self.client = Client()
        self.client.login(username=username, password=password)

    def logout(self):
        self.client.logout()

    def tearDown(self):
        self.logout()
        Item.objects.all().delete()
        ModelClient.objects.all().delete()
        User.objects.all().delete()
        Picture.objects.all().delete()
        Bill.objects.all().delete()

    def _test_get_logout(self, url):
        self.logout()
        self.response = self.client.get(url)
        self.assertEqual(self.response.status_code, 302)
Пример #49
0
class TestUserAdmin(TransactionTestCase):
    fixtures = ['init_panda.json']

    def setUp(self):
        self.user = utils.get_panda_user()
        
        self.client = Client()
        self.client.login(username='******', password='******')

    def tearDown(self):
        self.client.logout()

    def test_add_user(self):
        # Test fetching the form
        response = self.client.get(reverse('admin:auth_user_add'))
        
        self.assertEqual(response.status_code, 200)

        new_user = {
            'username': '******',
            'last_name': 'Barman'
        }

        # Test submitting the form
        response = self.client.post(reverse('admin:auth_user_add'), new_user)

        self.assertEqual(response.status_code, 302)

        created_user = User.objects.get(username='******')
        self.assertEqual(created_user.last_name, 'Barman')
Пример #50
0
    def test_lot_login_view_always_valid(self):
        c = Client()
        lots = LOT.objects.all().count()

        response = c.get('/login/{0}/'.format(self.lot3.uuid))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(int(c.session['_auth_user_id']), self.lot3.user_id)

        c.logout()
        self.assertFalse("_auth_user_id" in c.session)

        self.assertEqual(LOT.objects.all().count(), lots)

        response = c.get('/login/{0}/'.format(self.lot3.uuid))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(int(c.session['_auth_user_id']), self.lot3.user_id)

        c.logout()
        self.assertFalse("_auth_user_id" in c.session)

        self.assertEqual(LOT.objects.all().count(), lots)

        self.lot3.created = self.lot3.created - datetime.timedelta(days=10000)
        self.lot3.save(force_modification=True)

        response = c.get('/login/{0}/'.format(self.lot3.uuid))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(int(c.session['_auth_user_id']), self.lot3.user_id)

        self.assertEqual(LOT.objects.all().count(), lots)
Пример #51
0
class GroupTestCase(unittest.TestCase):
    def test_login(self):
        self.client = Client()
        self.user = User.objects.create_user(username = '******', password = '******')
        print 'user - ', self.user
        #login by username
        status =  self.client.login(username = '******', password = '******')
        print 'login', status

        response = self.client.get('/login/')
        self.assertEqual(response.status_code, 200)
        print 'response.status_code', response.status_code

        response = self.client.post('/Deanery/group/add/', {'name': 'testGroup', })
        self.assertEqual(response.status_code, 302)
        print 'response.status_code - ', response.status_code

        response = self.client.get('/Deanery/')

        g_list = response.context['ls_groups']
        print 'g_list - ',  smart_unicode(g_list)

        # add students

        last = g_list[len(g_list) - 1]
        gr_num = len(g_list) - 1
        print 'last - ',  last

        response = self.client.post('/Deanery/student/add/', {'fio':'testStudent','numticket':'777','groups':gr_num,'datebrd':'1981-01-01' })
        print 'response.status_code - ',  response.status_code

        std_list = Students.objects.all()
        print 'std_list - ',  smart_unicode(std_list)

        self.client.logout()
Пример #52
0
 def test_flag(self):
     self.q.flagged()
     self.assertEquals(self.q.flags_count, 1)
     c = Client()
     response = c.post(reverse('flag_question', kwargs={'q_id': self.q.id}))
     self.assertEquals(response.status_code, 200)
     data = json.loads(response.content)
     self.assertIn('redirect', data)
     respone = c.post(data['redirect'], {
         'username': "******",
         'password': "******"
     })
     response = c.post(reverse('flag_question', kwargs={'q_id': self.q.id}))
     data = json.loads(response.content)
     self.assertIn('message', data)
     self.assertEquals(
         data['message'],
         'Thank you for falgging the question. One of our editors will look at it shortly.'
     )
     self.q = Question.objects.get(pk=self.q.id)
     self.assertEquals(self.q.flags_count, 2)
     response = c.post(reverse('flag_question', kwargs={'q_id': self.q.id}))
     data = json.loads(response.content)
     self.assertIn('message', data)
     self.assertEquals(data['message'],
                       'Thanks.  You already reported this question')
     c.logout()
     self.assertTrue(c.login(username="******", password="******"))
     response = c.post(reverse('flag_question', kwargs={'q_id': self.q.id}))
     data = json.loads(response.content)
     self.assertIn('redirect', data)
     self.assertEquals(data['redirect'],
                       reverse('qna', args=(self.q.entity.slug, )))
Пример #53
0
    def test_tilestache_api(self):
        """Testing titlestache api tile generation"""

        client = Client()
        layer = Layer.objects.get(
            project=self.project.instance,
            qgs_layer_id='spatialite_points20190604101052075')
        assign_perm('view_project', self.anonymoususer, self.project.instance)

        # active caching for layer
        cachinglayer = G3WCachingLayer.objects.create(app_name='qdjango',
                                                      layer_id=layer.pk)

        # init tilestache
        TilestacheConfig.set_cache_config_dict(TilestacheConfig().config_dict)

        url = reverse('caching-api-tile',
                      args=[f'qdjango{layer.pk}', 0, 0, 0, 'png'])
        #url = f'{self.live_server_url}{url}'
        self.assertTrue(
            client.login(username=self.test_admin1.username,
                         password=self.test_admin1.username))

        res = client.get(url)
        self.assertEqual(res.status_code, 200)

        client.logout()
Пример #54
0
    def test_map_save(self):
        """POST /maps -> Test saving a new map"""

        c = Client()

        # Test that saving a map when not logged in gives 401
        response = c.post("/maps/",data=MapTest.viewer_config,content_type="text/json")
        self.assertEqual(response.status_code,401)

        # Test successful new map creation
        c.login(username="******", password="******")
        response = c.post("/maps/",data=MapTest.viewer_config,content_type="text/json")
        self.assertEquals(response.status_code,201)
        map_id = int(response['Location'].split('/')[-1])
        c.logout()

        self.assertEquals(map_id,2)
        map_obj = Map.objects.get(id=map_id)
        self.assertEquals(map_obj.title, "Title")
        self.assertEquals(map_obj.abstract, "Abstract")
        self.assertEquals(map_obj.layer_set.all().count(), 1)
        self.assertEquals(map_obj.keyword_list(), ["keywords", "saving"])

        # Test an invalid map creation request
        c.login(username="******", password="******")
        response = c.post("/maps/",data="not a valid viewer config",content_type="text/json")
        self.assertEquals(response.status_code,400)
        c.logout()
Пример #55
0
class TestDataRetention(TestCase):

    def setUp(self):
        self.c = Client()
        self.user = User.objects.create_user(password='******', email='*****@*****.**')
        self.c.login(username='******', password='******')

    def tearDown(self):
        self.c.logout()
        User.objects.all().delete()


    def test_data_retention_form(self):
        url = reverse('settings_data')

    
        response = self.c.post(url, {'check_every': 60, 'keep_data': 30})

        
        result = data_retention_model.get_one()

        assert result['check_every'] == 60
        assert result['keep_data'] == 30



        response = self.c.post(url, {'check_every': 300, 'keep_data': 60})

        result = data_retention_model.get_one()

        assert result['check_every'] == 300
        assert result['keep_data'] == 60
Пример #56
0
 def test_optional_email_verification(self):
     c = Client()
     # Signup
     c.get(reverse('account_signup'))
     resp = c.post(reverse('account_signup'),
                   {'username': '******',
                    'email': '*****@*****.**',
                    'password1': 'johndoe',
                    'password2': 'johndoe'})
     # Logged in
     self.assertEqual(resp['location'],
                      'http://testserver'+settings.LOGIN_REDIRECT_URL)
     self.assertEqual(resp.status_code, 302)
     self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
     self.assertEqual(len(mail.outbox), 1)
     # Logout & login again
     c.logout()
     # Wait for cooldown
     EmailConfirmation.objects.update(sent=now() - timedelta(days=1))
     # Signup
     resp = c.post(reverse('account_login'),
                   {'login': '******',
                    'password': '******'})
     self.assertEqual(resp.status_code, 302)
     self.assertEqual(resp['location'],
                      'http://testserver'+settings.LOGIN_REDIRECT_URL)
     self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
     # There was an issue that we sent out email confirmation mails
     # on each login in case of optional verification. Make sure
     # this is not the case:
     self.assertEqual(len(mail.outbox), 1)
Пример #57
0
    def test_bobby_cannot_set_all(self):
        """Test that Bobby can set the permissions only only on the ones
        for which he has the right"""

        layer = Layer.objects.all()[0]
        c = Client()
        c.login(username='******', password='******')
        # give bobby the right to change the layer permissions
        assign_perm('change_resourcebase',
                    Profile.objects.get(username='******'),
                    layer.get_self_resource())
        c.logout()
        c.login(username='******', password='******')
        layer2 = Layer.objects.all()[1]
        data = {
            'permissions':
            json.dumps({
                "users": {
                    "bobby": ["view_resourcebase"]
                },
                "groups": {}
            }),
            'resources': [layer.id, layer2.id]
        }
        resp = c.post(self.bulk_perms_url, data)
        self.assertTrue(
            layer2.title in json.loads(resp.content)['not_changed'])