Beispiel #1
0
class OrderViewTests(TestCase):
	def setUp(self):
		self.testuser = User.objects.create_user(username='******',password='******',
											first_name='test',last_name='user')
		self.testusersp = add_sellerprofile(self.testuser)
		self.c = Client()
		self.c.login(username='******',password='******')
		self.assertTrue(self.c.login)
		self.testuser2 = User.objects.create_user(username='******',password='******')
		self.d = Client()
		self.d.login(username='******',password='******')
		self.assertTrue(self.d.login)
		self.testcat = add_cat('testcat')
		self.cash = PaymentChoice.objects.create(description='cash')
		self.testitem = add_item(title='testitem',asking_price=100,
							category=self.testcat,owner=self.testusersp)
		self.order = Order.objects.create(buyer=self.testuser2,meetuploc='pielantis',
										  phone=12313132,paymentmethod=self.cash,buy_item=self.testitem)

	def tearDown(self):
		self.c.logout()
		self.d.logout()

	def test_user_without_sellerprofile_can_access_order_page(self):
		response = self.d.get(reverse('shop:order', kwargs={'order_id': self.order.id}))
		self.assertEqual(response.status_code, 200)
Beispiel #2
0
class AddNewItemViewTests(TestCase):
	def setUp(self):
		testuser = User.objects.create_user(username='******',password='******')
		testusersp = add_sellerprofile(testuser)
		self.c = Client()
		self.c.login(username='******',password='******')
		self.assertTrue(self.c.login)

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

	def test_valid_saleitem_creation(self):

		testcat = add_cat('testcat')
		data = {'title': 'testtitle','condition': 'NEW',
				'description': 'its legit',
				'asking_price': 334334,
				'payment_type':'COD',
				'negotiable': True,
				'expiration_date': '4/4/2015',
				'category': testcat.id,
				'refundable': True,
				'home_delivery': True}

		form = SaleItemForm(data=data)
		print form.errors
		self.assertTrue(form.is_valid())
		response = self.c.post(reverse('shop:add_new_item'), data)
		self.assertEqual(response.status_code, 302)
Beispiel #3
0
class AcceptBidViewTests(TestCase):
	def setUp(self):
		self.testuser = User.objects.create_user(username='******',password='******')
		self.testusersp = add_sellerprofile(self.testuser)
		self.c = Client()
		self.c.login(username='******',password='******')
		self.assertTrue(self.c.login)
	def tearDown(self):
		self.c.logout()


	def test_valid_accept_bid(self):
		testcat = add_cat('testcat')
		testitem = add_item(title='testitem',asking_price=100,
							category=testcat,owner=self.testusersp)
		self.assertTrue(testitem.available)
		testbid = UserBid.objects.create(user=self.testuser,sale_item=testitem,offer_price=200)
		response = self.c.post(reverse('shop:acceptbid', kwargs={'bid_id':testbid.id}))
		self.assertEqual(response.status_code, 302)
		testitemafter = SaleItem.objects.get(slug='testitem')
		self.assertEqual(testitemafter.accepted_bid, testbid)
		self.assertFalse(testitemafter.available)


	def test_item_owner_can_access_accept_bid_view(self):
		testcat = add_cat('testcat')
		testitem = add_item(title='testitem',asking_price=100,
							category=testcat,owner=self.testusersp)
		self.assertTrue(testitem.available)
		testbid = UserBid.objects.create(user=self.testuser,sale_item=testitem,offer_price=200)
		response = self.c.get(reverse('shop:acceptbid', kwargs={'bid_id':testbid.id}))
		self.assertEqual(response.status_code, 200)
		self.assertEqual(response.context['bid'], testbid)
Beispiel #4
0
    def test_index(self):
        """
        Test for the main view.
        """

        c = Client()
        response = c.get(reverse('file_service', kwargs=dict(key='test')))

        # Non-authenticated user should return 401
        self.assertEqual(response.status_code, 401)

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

        # An authenticated user should return a 200
        response = c.get(reverse('file_service', kwargs=dict(key='test')))
        self.assertEqual(response.status_code, 200)

        c.logout()

        # A client should get a 200 response with basic authorization
        headers = dict(HTTP_AUTHORIZATION="basic dGVzdF9hZG1pbjphZG1pbg==")
        response = c.get(reverse('file_service', kwargs=dict(key='test')), **headers)
        self.assertEqual(response.status_code, 200)

        # A client should get a 401 response with incorrect basic authorization
        headers = dict(HTTP_AUTHORIZATION="basic dGasdasdsabg==")
        response = c.get(reverse('file_service', kwargs=dict(key='test')), **headers)
        self.assertEqual(response.status_code, 401)
class homePage(TestCase):

    def setUp(self):
        self.client = Client()

    def test_login(self):
        self.assertEquals(reverse("audio:index"), '/audio/')

    def test_anon(self):
        response = self.client.get(reverse("login"))
        self.assertEquals(response.status_code, 200)
        response = self.client.get(reverse("audio:index"))
        self.assertEquals(response.status_code, 302)


    def test_not_anon(self):

        user = User.objects.create_user(
            username="******",
            password="******"
        )

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

        self.assertTrue(login_status)

        response = self.client.get(reverse("login"))
        self.assertEquals(response.status_code, 302)
        response = self.client.get(reverse("audio:index"))
        self.assertEquals(response.status_code, 200)
        self.client.logout()
Beispiel #6
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',
        }

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

    def test_fail_gracefully(self):
        """Do we fail gracefully when an invalid alert form is sent?"""
        # Use a copy to shield other tests from changes.
        bad_alert_params = self.alert_params.copy()
        # Break the form
        bad_alert_params.pop('query', None)
        self.client.login(username='******', password='******')
        r = self.client.post('/', bad_alert_params, follow=True)
        self.assertEqual(r.status_code, 200)
        self.assertIn('error creating your alert', r.content)
        self.client.logout()
Beispiel #7
0
	def test_anonymous(self):
		# Load the page with a user, should load as normal
		c = Client()
		response = c.get('/nation/1/',follow=True)
		self.assertEqual(response.redirect_chain,[])
		self.assertEqual(response.status_code,200)
		c.logout()
Beispiel #8
0
    def test_mi_panel(self):
        """
        Comprueba la vista mi_panel

        Comprueba que muestra las reservas del profesor si el usuario es un profesor
        Comprueba que muestra los datos del admin si el usuario es un admin
        Comprueba que muestra las opciones del alumno si el usuario es un alumno
        """
        c = Client()
        c.login(username="******", password="******")
        response = c.post('/miPanel/')
        boolean = True if 'reservas' in response.context['datos'] else False
        self.assertEquals(boolean, True)
        c.logout()

        c.login(username="******", password="******")
        response = c.post('/miPanel/')
        boolean = True if 'usuarios' in response.context['datos'] else False
        self.assertEquals(boolean, True)
        c.logout()

        c.login(username="******", password="******")
        response = c.post('/miPanel/')
        boolean = True if 'reservas' in response.context else False
        self.assertEquals(boolean, False)
Beispiel #9
0
class MainPageTestCase(TestCase):
    
    def _create_packages(self, user):
        for x in xrange(self.COUNT):
            Package.objects.create(title=self.PACKAGE_NAME_TEMPLATE % (user.username,x),
                                   user=user)
    
    def setUp(self):
        
        _create_basic_database()
        self.c = Client()
        # login
        self.c.login(username=TEST_USER, password=TEST_PASSWORD)
    
    def test_basic_elements(self):
        response = self.c.get('/exeapp/')
        self.assertContains(response, "Main Page")
        self.assertContains(response, "Package")
        
    def _test_create_package(self):
        PACKAGE_NAME = '%s Package post' % self.TEST_USER
        response = self.s.app.register(PACKAGE_NAME)
        p = Package.objects.get(title=PACKAGE_NAME)
        self.assertTrue(p.user.username == self.TEST_USER)
        
        
    def test_require_login(self):
        self.c.logout()
        response = self.c.get('/exeapp/main')
        self.assertFalse('Main Page' in response.content)
class TestSignUpView(TestCase):

    def setUp(self):
        self.user = self.create_user_django()
        self.client = Client()

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

    def create_user_django(self):
        user = User.objects.create_user("USERtestCoLaB",
                                        "*****@*****.**", "123colab4")
        return user

    def test_user_authenticated_and_unregistered(self):
        self.client.login(username="******", password="******")
        response = self.client.get("/account/register/")
        self.assertEquals(200, response.status_code)
        self.client.logout()

    def test_user_authenticated_and_registered(self):
        self.user.needs_update = False
        self.user.save()
        self.client.login(username="******", password="******")
        response = self.client.get("/account/register/")
        self.assertEquals(302, response.status_code)
        url = "http://testserver/account/usertestcolab"
        self.assertEquals(url, response.url)
        self.client.logout()
Beispiel #11
0
class ModelsTestCase(TestCase):

    def setUp(self):
        self.u = User.objects.create(username='******', password='******')
        self.u2 = User.objects.create(username='******', password='******')
        self.c = Category.objects.create(category_name='test_category')

        self.client = Client()
        self.request = RequestFactory()

    def testPurchasedProductsPageRedirect(self):
        self.client.logout()
        response = self.client.get(reverse('bidplacing:purchased_products_page'))

        self.assertEqual(response.status_code, 302)

    def testAddProduct(self):
        request = self.request.post(reverse('bidplacing:new_product'), {'product_name': 'test_product',
                                                                        'start_price': 5,
                                                                        'category': self.c})
        request.user = self.u
        response = new_product(request)

        self.assertEqual(response.status_code, 200)

    def testAddProductNegativePrice(self):
        form = ProductForm({'product_name': 'test_product',
                            'start_price': -64,
                            'category': self.c})

        self.assertFalse(form.is_valid())
class SessionAuthTests(TestCase):
    """User session authentication"""
    urls = 'djangorestframework.tests.authentication'

    def setUp(self):
        self.csrf_client = Client(enforce_csrf_checks=True)
        self.non_csrf_client = Client(enforce_csrf_checks=False)
        self.username = '******'
        self.email = '*****@*****.**'
        self.password = '******'
        self.user = User.objects.create_user(self.username, self.email, self.password)

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

    def test_post_form_session_auth_failing_csrf(self):
        """Ensure POSTing form over session authentication without CSRF token fails."""
        self.csrf_client.login(username=self.username, password=self.password)
        response = self.csrf_client.post('/', {'example': 'example'})
        self.assertEqual(response.status_code, 403)

    def test_post_form_session_auth_passing(self):
        """Ensure POSTing form over session authentication with logged in user and CSRF token passes."""
        self.non_csrf_client.login(username=self.username, password=self.password)
        response = self.non_csrf_client.post('/', {'example': 'example'})
        self.assertEqual(response.status_code, 200)

    def test_post_form_session_auth_failing(self):
        """Ensure POSTing form over session authentication without logged in user fails."""
        response = self.csrf_client.post('/', {'example': 'example'})
        self.assertEqual(response.status_code, 403)
Beispiel #13
0
class AdminLoginTest(TestCase):
    def setUp(self):
        self.new_user = User.objects.create_user(username='******', password='******')
        self.client = Client()

    def test_login_display(self):
        response = self.client.get('/admin/')
        self.assertEqual(response.status_code, 200)

        response = self.client.get('/admin/main/', follow=True)
        self.assertEqual(response.status_code, 404)

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

        response = self.client.get('/admin/main/')
        self.assertEqual(response.status_code, 200)

        self.client.logout()

        response = self.client.get('/admin/main/', follow=True)
        self.assertEqual(response.status_code, 404)

    def test_login_fail(self):
        response = self.client.login(username='******', password='******')
        self.assertFalse(response)

        response = self.client.get('/admin/main/', follow=True)
        self.assertEqual(response.status_code, 404)
Beispiel #14
0
class GradeViewTest(TestCase):
    def setUp(self):
        self.client = Client()

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

    def test_grade_view(self):
        # Given
        # URL redirection due to no login credentials
        status_code = 302
        # When
        response = self.client.get(reverse('grades:grading_systems'))
        # Then
        self.assertEqual(response.status_code, status_code)

        # Given
        # successful login and grading systems views
        self.client.login(username='******', password='******')
        status_code = 200
        # When
        response = self.client.get(reverse('grades:grading_systems'))
        # Then
        self.assertEqual(response.status_code, status_code)
        self.assertTemplateUsed(response, 'grading_systems.html')
Beispiel #15
0
class HomePageTest(TestCase):
    
    def setUp(self):
        self.c = Client()
        self.user = User.objects.create(username='******',password='******')
        self.user.set_password('hello')
        self.user.save()
        # A dummy user for testing...

    def test_root_url_resolves_to_index_view(self):
        found = resolve('/')
        self.assertEqual(found.func, index)
    
    def test_existing_login(self):
        login = self.c.login(username='******',password='******')
        if login :
            self.c.logout()
        self.assertTrue(login)

    def test_non_existing_login(self):
        login2 = authenticate(username='******', password='******')
        # login2 == None implies the user doesn't exist...
        self.assertEqual(login2,None)

    def test_incorrect_password(self):
        user3 = authenticate(username='******',password='******')
        login3 = self.c.login(username='******',password='******')
        # login3 == False implies the user's credentials are invalid...
        self.assertTrue(not login3 and user3 != None)
Beispiel #16
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())
Beispiel #17
0
class TestProfileViewing(TestCase):
    def setUp(self):
        self.c = Client()
        r = RedditUser.objects.create(user=User.objects.create_user(username="******", password="******"))

        r.first_name = "First Name"
        r.last_name = "Last Name"
        r.about_html = "about html text"
        r.github = "example"

    def test_existing_username(self):
        r = self.c.get(reverse("user_profile", args=("username",)))
        self.assertEqual(r.status_code, 200)
        self.assertContains(r, "(username)")
        self.assertContains(r, "compose?to=username")
        self.assertNotContains(r, "/profile/edit")
        self.assertNotContains(r, "First Name")
        self.assertNotContains(r, "Last Name")
        self.assertNotContains(r, "about html text")
        self.assertNotContains(r, "https://github.com/example")

    def test_own_username(self):
        self.assertTrue(self.c.login(username="******", password="******"))
        r = self.c.get(reverse("user_profile", args=("username",)))
        self.assertContains(r, "/profile/edit")
        self.assertNotContains(r, "compose?to=username")
        self.c.logout()

    def test_invalid_username(self):
        r = self.c.get(reverse("user_profile", args=("none",)))
        self.assertEqual(r.status_code, 404)
Beispiel #18
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"}

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

    def test_fail_gracefully(self):
        """Do we fail gracefully when an invalid alert form is sent?"""
        # Use a copy to shield other tests from changes.
        bad_alert_params = self.alert_params.copy()
        # Break the form
        bad_alert_params.pop("query", None)
        self.client.login(username="******", password="******")
        r = self.client.post("/", bad_alert_params, follow=True)
        self.assertEqual(r.status_code, 200)
        self.assertIn("error creating your alert", r.content)
        self.client.logout()
Beispiel #19
0
class LogoutTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.register_user = {
            'username': "******",
            'email': '*****@*****.**',
            'password': "******",
        }
        self.log_user = {
            'username': self.register_user['username'],
            'password': self.register_user['password'],
        }
        unittest_fr = User.objects.create_user(**self.register_user)
        UserLang.objects.create(user=unittest_fr, lang='fr')

    def test_logout_user(self):
        self.client.login(username=self.log_user['username'], password=self.log_user['password'])
        reponse = self.client.get(reverse('logout'))
        self.assertEqual(reponse.status_code, 301)
        self.client.logout()

    def test_logout_url_unlog(self):
        """
        tests access to url contact not log status

        :var reponse: response of request
        :todo: see how to remove next when referer is logout
        :return: None
        """
        reponse = self.client.get(reverse('logout'))
        self.assertRedirects(reponse, reverse('login') + '?next=' + reverse('logout'))
class UserPageTest(TestCase):

    def setUp(self):
        self.client = Client()
        self.username = '******'
        self.email = '*****@*****.**'
        self.password = '******'
        self.test_user = User.objects.create_superuser(self.username, self.email, self.password)
        login = self.client.login(username=self.username, password=self.password)

    def test_user_view_exists(self):
        request = HttpRequest()
        Bob = User.objects.get(username='******')
        request.user = Bob
        response =  user_page(request)
        self.assertContains(response, 'Change Password')

    def test_user_page_exists(self):
        response = self.client.get('/user/')
        self.assertEquals(response.status_code, 200)

    def test_user_page_requires_login(self):
        self.client.logout()
        response = self.client.get('/user/')
        self.assertRedirects(response, '/login/?next=/user/', status_code=302)

    def test_user_page_shows_correct_links(self):
        response = self.client.get('/user/')
        self.assertContains(response, "Reset Password")
        self.assertContains(response, "Logout")
Beispiel #21
0
class ThreadUrlsTestCase(BaseTestCase):

    def setUp(self):
        super(ThreadUrlsTestCase, self).setUp()
        self.client = Client()

    def tearDown(self):
        self.client.logout()
        super(ThreadUrlsTestCase, self).tearDown()

    def test_new_url(self):
        self.client.login(
            username=self.user.username, password=self._password)
        response = self.client.get(reverse('threads:new'))
        self.assertEqual(response.status_code, 200)

    def test_show_url(self):
        forum = Forum.objects.create(
            name='Forum',
            description='A forum',
            active=True,
        )
        thread = Thread.objects.create(subject='Thread', forum=forum)

        response = self.client.get(reverse(
            'threads:show', kwargs={'slug': thread.slug}))
        self.assertEqual(response.status_code, 200)

    def test_show_url_not_valid(self):
        response = self.client.get(reverse(
            'threads:show', kwargs={'slug': 'does-not-exist'}))
        self.assertEqual(response.status_code, 404)
class SignOut(TestCase):
    def setUp(self):
        self.client = Client()
        self.chester = User.objects.create_user(first_name='Chester',
                                                last_name='Tester',
                                                email='*****@*****.**',
                                                username='******',
                                                password='******')
        self.client.logout()

    def tearDown(self):
        pass

    def test_010_SignOutNotSignedIn(self):
        """Sign Out when no-one is signed in - should not result in an error"""
        ts = now()
        self.assertFalse('_auth_user_id' in self.client.session)
        r = self.client.get(reverse('User:SignOut'))
        self.assertEqual(r.resolver_match.func.__name__, views.SignOut.__name__)
        self.assertRedirects(r, reverse('Home'))
        self.assertFalse('_auth_user_id' in self.client.session)
        self.assertTrue(PageVisit.most_recent(document='User:SignOut', user=None) is None)

    def test_011_SignOutOk(self):
        """Sign Out when user is signed in - must result in correct logout"""
        ts = now()
        self.assertTrue(self.client.login(username='******', password='******'))
        self.assertTrue(self.client.session['_auth_user_id'], self.chester.pk)
        response = self.client.get(reverse('User:SignOut'))
        self.assertRedirects(response, reverse('Home'))
        self.assertFalse('_auth_user_id' in self.client.session)
        self.assertAlmostEqual(PageVisit.most_recent('User:SignOut').timestamp, ts, delta=timedelta(milliseconds=200))
Beispiel #23
0
 def test_first_time(self):
     # check that system detects first time user
     c = Client()
     c.logout()
     c.login(username="******", password="******")
     response = c.get("/settings", follow=True)
     self.assertIn(b"first time", response.content)
Beispiel #24
0
    def test_user_data1(self):
        '''
        Another method for basic tests.
        :return:
        '''
        c = Client()

        response = self.client.post('/signup/', {'username': '******',
                                                'password': '******',
                                                'email': '*****@*****.**',
                                                'first_name': 'old_first_name2',
                                                'last_name': 'old_last_name'})
        self.assertEqual(200, response.status_code)

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

        response=c.post('/change_user_data/', {'new_first_name': 'newFN',
                                                   'new_last_name': 'newLN',
                                                   'new_email': '*****@*****.**'})
        self.assertEqual(302, response.status_code)

        user = User.objects.get(username='******')


        self.assertEqual("newFN",user.first_name)
        self.assertEqual("newLN",user.last_name)
        self.assertEqual("*****@*****.**",user.email)
Beispiel #25
0
class AdminTest(LiveServerTestCase):
	fixtures = ['users.json']

	def setUp(self):
		self.client = Client()

	def test_Login(self):
		response = self.client.get('/admin/', follow=True)
		self.assertEquals(response.status_code, 200)
		
		self.assertTrue(b"Log in" in response.content)

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

		response = self.client.get('/admin/', follow=True)
		self.assertEquals(response.status_code, 200)

		self.assertTrue(b"Log out" in response.content)

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

		response = self.client.get('/admin/', follow=True)
		self.assertEquals(response.status_code, 200)

		self.assertTrue(b"Log out" in response.content)

		self.client.logout()

		response = self.client.get('/admin/', follow=True)
		self.assertEquals(response.status_code, 200)

		self.assertTrue(b"Log in" in response.content)
Beispiel #26
0
class TestOperateCategoryView(BasePlanCase):
    """Tests for operating category on cases"""

    @classmethod
    def setUpTestData(cls):
        super(TestOperateCategoryView, cls).setUpTestData()

        cls.case_cat_full_auto = TestCaseCategoryFactory(name='Full Auto', product=cls.product)
        cls.case_cat_full_manual = TestCaseCategoryFactory(name='Full Manual', product=cls.product)

        cls.tester = User.objects.create(username='******', email='*****@*****.**')
        cls.tester.set_password('password')
        cls.tester.save()

        user_should_have_perm(cls.tester, 'testcases.add_testcasecomponent')

        cls.case_category_url = reverse('tcms.testcases.views.category')

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

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

    def test_show_categories_form(self):
        response = self.client.post(self.case_category_url, {'product': self.product.pk})

        self.assertContains(
            response,
            '<option value="{}" selected="selected">{}</option>'.format(
                self.product.pk, self.product.name),
            html=True)

        categories = ('<option value="{}">{}</option>'.format(category.pk, category.name)
                      for category in self.product.category.all())
        self.assertContains(
            response,
            '''<select multiple="multiple" id="id_o_category" name="o_category">
{}
</select>'''.format(''.join(categories)),
            html=True)

    def test_update_cases_category(self):
        post_data = {
            'from_plan': self.plan.pk,
            'product': self.product.pk,
            'case': [self.case_1.pk, self.case_3.pk],
            'a': 'update',
            'o_category': self.case_cat_full_auto.pk,
        }
        response = self.client.post(self.case_category_url, post_data)

        data = json.loads(response.content)
        self.assertEqual({'rc': 0, 'response': 'ok', 'errors_list': []}, data)

        for pk in (self.case_1.pk, self.case_3.pk):
            case = TestCase.objects.get(pk=pk)
            self.assertEqual(self.case_cat_full_auto, case.category)
Beispiel #27
0
class UpdateProfileTests(TestCase):
    def setUp(self):
        self.c = Client()
        response = self.c.post(reverse('register'),
                                    data={'firstname': 'Test',
                                          'lastname': 'User',
                                          'email': '*****@*****.**',
                                          'password1': '1234',
                                          'password2': '1234'}, follow=True)
        self.newUser = UserProfile.objects.latest('user')
        self.failUnlessEqual(response.status_code, 200)
        
    def test_change_username(self):
        self.c.post(reverse('login'),
                {   'email': '*****@*****.**',
                    'password': '******'}, follow=True)
        response = self.c.post(reverse('updateUser'),
                {'firstname': 'Altered',
                 'lastname': 'Test',
                 'userPassword': '******'}, follow=True)
        self.failUnlessEqual(response.status_code, 200)
        self.assertEqual(self.newUser.user.first_name, 'Altered')
        self.assertEqual(self.newUser.user.last_name, 'Test')
        
       
    def test_change_password(self):
        response = self.c.post(reverse('updateUser'),
                {   'password1': '4321',
                    'password2': '4321',
                    'userPassword': '******'}, follow=True)
        self.failUnlessEqual(response.status_code, 200)
        username = self.newUser.user.username
        self.c.logout()
        self.failUnlessEqual(self.c.login(username=username, password='******'), True)

    def test_password_failure(self):
        response = self.c.post(reverse('updateUser'),
                                    data={'firstname': 'Frank',
                                          'userPassword': '******'})
        self.assertEqual(response.status_code, 200)
        self.failIf(response.context['form'].is_valid())
        self.assertFormError(response, 'form', field=None, errors=u'Password incorrect, try again')


    def test_change_password_failure(self):
        response = self.c.post(reverse('updateUser'),
                data={  'password1': 4321,
                        'password2': 5321,
                        'userPassword': '******'})
        self.assertEqual(response.status_code, 200)
        self.failIf(response.context['form'].is_valid())
        self.assertFormError(response, 'form', field=None, errors=u'You must type the same password each time')


    def test_delete_account(self):
        amountUsers = UserProfile.objects.count()
        response = self.c.get(reverse('delete_user'), follow=True)
        self.failUnlessEqual(response.status_code, 200)
        self.assertEqual(amountUsers-1, UserProfile.objects.count())
Beispiel #28
0
 def test_basic_hijack(self):
     client = Client()
     client.login(username=self.superuser_username, password=self.superuser_password)
     hijacked_response = client.post('/hijack/%d/' % self.user.id, follow=True)
     self.assertEqual(hijacked_response.status_code, 200)
     hijack_released_response = client.post('/hijack/release-hijack/', follow=True)
     self.assertEqual(hijack_released_response.status_code, 200)
     client.logout()
Beispiel #29
0
 def test_account_creation(self):
     # check that account creation goes off successfully
     c = Client()
     c.logout()
     Account.objects.all().delete()
     c.login(username="******", password="******")
     response = c.post("/settings/", {"vcode": "345Xgfh43", "keyid": "122345"})
     self.assertIn(b"Account Created", response.content)
Beispiel #30
0
 def test_handle_user_logout_no_user(self):
     """
     Test if logout events are correctly handled when user was not login before logout.
     """
     client = Client()
     client.logout()
     nb_events = LogEvent.objects.count()
     self.assertEqual(nb_events, 0)
Beispiel #31
0
class SessionDetailsViewTest(TestCase):
    @classmethod
    def setUpClass(cls):
        super(SessionDetailsViewTest, cls).setUpClass()
        cls.domain = Domain(name="toyland", is_active=True)
        cls.domain.save()
        cls.couch_user = CommCareUser.create(cls.domain.name, 'bunkey', '123',
                                             None, None)
        cls.sql_user = cls.couch_user.get_django_user()

        cls.expected_response = {
            'username': cls.sql_user.username,
            'djangoUserId': cls.sql_user.pk,
            'superUser': cls.sql_user.is_superuser,
            'authToken': None,
            'domains': [cls.domain.name],
            'anonymous': False,
            'enabled_toggles': [],
            'enabled_previews': [],
        }
        cls.url = reverse('session_details')

    def setUp(self):
        # logs in the mobile worker every test so a new session is setup
        self.client = Client()
        self.client.login(username='******', password='******')

        self.session = self.client.session
        self.session.save()
        self.session_key = self.session.session_key

    @classmethod
    def tearDownClass(cls):
        cls.couch_user.delete(cls.domain.name, deleted_by=None)
        cls.domain.delete()
        super(SessionDetailsViewTest, cls).tearDownClass()

    def _assert_session_expiry_in_minutes(self, expected_minutes,
                                          actual_time_string):
        delta = parse_datetime(actual_time_string) - datetime.datetime.utcnow(
        ).replace(tzinfo=pytz.utc)
        diff_in_minutes = delta.days * 24 * 60 + delta.seconds / 60
        self.assertEqual(expected_minutes, round(diff_in_minutes))

    @softer_assert()
    def test_session_details_view(self):
        data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'})
        response = _post_with_hmac(self.url,
                                   data,
                                   content_type="application/json")
        self.assertEqual(200, response.status_code)
        self.assertJSONEqual(response.content, self.expected_response)

    @softer_assert()
    def test_session_details_view_expired_session(self):
        self.session.set_expiry(-1)  # 1 second in the past
        self.session.save()
        data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'})
        response = _post_with_hmac(self.url,
                                   data,
                                   content_type="application/json")
        self.assertEqual(404, response.status_code)

    @softer_assert()
    def test_session_details_view_updates_session(self):
        expired_date = self.session.get_expiry_date()
        data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'})
        response = _post_with_hmac(self.url,
                                   data,
                                   content_type="application/json")
        self.assertEqual(200, response.status_code)
        self.assertGreater(self.session.get_expiry_date(), expired_date)

    @flag_enabled('SECURE_SESSION_TIMEOUT')
    def test_secure_sessions(self):
        def _assertSecureSessionExpiry(previous_expiry, timeout_in_minutes):
            self.assertEqual(True, self.client.session.get('secure_session'))
            self.assertEqual(timeout_in_minutes,
                             self.client.session.get('secure_session_timeout'))
            self.assertNotEqual(previous_expiry,
                                self.client.session.get_expiry_date())
            expiring_in = (self.client.session.get_expiry_date() -
                           datetime.datetime.utcnow()).seconds
            self.assertGreater(expiring_in, timeout_in_minutes * 60 - 2)
            self.assertLess(expiring_in, timeout_in_minutes * 60 + 2)

        # Turn on secure sessions
        self.domain.secure_sessions = True
        self.domain.save()

        # Sessions should now be secure and use timeout from settings
        expired_date = self.session.get_expiry_date()
        self.client.get(reverse('domain_homepage', args=[self.domain.name]))
        _assertSecureSessionExpiry(expired_date, settings.SECURE_TIMEOUT)

        # Turn on customized timeout
        custom_timeout = 10
        self.domain.secure_sessions_timeout = custom_timeout
        self.domain.save()

        # Request a domain-specific page so the domain-specific timeout kicks in
        expired_date = self.session.get_expiry_date()
        self.client.get(reverse('domain_homepage', args=[self.domain.name]))
        _assertSecureSessionExpiry(expired_date, custom_timeout)

        # Request a non-domain-specific page, which still uses the domain-specific timeout saved in the session
        expired_date = self.session.get_expiry_date()
        self.client.get(reverse('ping_session'))
        _assertSecureSessionExpiry(expired_date, custom_timeout)

        # Test the session details view itself
        expired_date = self.session.get_expiry_date()
        data = json.dumps({
            'sessionId': self.session_key,
            'domain': self.domain.name
        })
        response = _post_with_hmac(self.url,
                                   data,
                                   content_type="application/json")
        self.assertEqual(200, response.status_code)
        _assertSecureSessionExpiry(expired_date, custom_timeout)

        # Going back to insecure sessions requires a logout to create a new session
        self.domain.secure_sessions_timeout = None
        self.domain.secure_sessions = False
        self.domain.save()
        self.client.logout()
        self.client.login(username='******', password='******')
        self.client.get(reverse('domain_homepage', args=[self.domain.name]))
        self.assertEqual(False, self.client.session.get('secure_session'))
        self.assertEqual(settings.INACTIVITY_TIMEOUT,
                         self.client.session.get('secure_session_timeout'))

    def test_ping_login_unauth_user(self):
        client = Client()
        client.login(username='******', password='******')
        response = client.get(reverse('ping_login'))
        self.assertEqual(200, response.status_code)
        data = json.loads(response.content)
        self.assertFalse(data['success'])
        self.assertIsNone(data['session_expiry'])
        self.assertIsNone(data['secure_session_timeout'])
        self.assertFalse(data['secure_session'])
        self.assertEqual("", data['username'])

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

        # First ping after login via client.login: authorized but no session expiry
        response = client.get(reverse('ping_login'))
        self.assertEqual(200, response.status_code)
        data = json.loads(response.content)
        self.assertTrue(data['success'])
        self.assertIsNone(data['session_expiry'])
        self.assertIsNone(data['secure_session_timeout'])
        self.assertFalse(data['secure_session'])
        self.assertEqual(self.couch_user.username, data['username'])

        # Request a page and then re-ping: session expiry should be based on INACTIVITY_TIMEOUT
        client.get(reverse('bsd_license'))
        response = client.get(reverse('ping_login'))
        data = json.loads(response.content)
        self.assertTrue(data['success'])
        self.assertEqual(self.couch_user.username, data['username'])
        self.assertFalse(data['secure_session'])
        self.assertEqual(settings.INACTIVITY_TIMEOUT,
                         data['secure_session_timeout'])
        self._assert_session_expiry_in_minutes(settings.INACTIVITY_TIMEOUT,
                                               data['session_expiry'])

        # Ping some more, session_expiry should not change
        session_expiry = data['session_expiry']
        client.get(reverse('ping_login'))
        response = client.get(reverse('ping_login'))
        data = json.loads(response.content)
        self.assertTrue(data['success'])
        self.assertEqual(self.couch_user.username, data['username'])
        self.assertEqual(session_expiry, data['session_expiry'])

        # Request a normal page, session_expiry should update
        client.get(reverse('bsd_license'))
        response = client.get(reverse('ping_login'))
        data = json.loads(response.content)
        self.assertTrue(data['success'])
        self.assertEqual(self.couch_user.username, data['username'])
        self.assertIsNotNone(data['session_expiry'])
        self.assertNotEqual(session_expiry, data['session_expiry'])

    def test_with_hmac_signing(self):
        data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'})
        header_value = get_hmac_digest(settings.FORMPLAYER_INTERNAL_AUTH_KEY,
                                       data)
        response = Client().post(self.url,
                                 data,
                                 content_type="application/json",
                                 HTTP_X_MAC_DIGEST=header_value)
        self.assertEqual(200, response.status_code)
        self.assertJSONEqual(response.content, self.expected_response)

    def test_with_hmac_signing_fail(self):
        data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'})

        response = Client().post(self.url,
                                 data,
                                 content_type="application/json",
                                 HTTP_X_MAC_DIGEST='bad signature')
        self.assertEqual(401, response.status_code)

    @softer_assert()
    @flag_enabled('FORM_LINK_WORKFLOW')
    @flag_enabled('CALC_XPATHS', is_preview=True)
    def test_session_details_view_toggles(self):
        toggles.all_toggles()
        data = json.dumps({'sessionId': self.session_key, 'domain': 'domain'})
        response = _post_with_hmac(self.url,
                                   data,
                                   content_type="application/json")
        self.assertEqual(200, response.status_code)
        expected_response = self.expected_response.copy()
        expected_response['enabled_toggles'] = ['FORM_LINK_WORKFLOW']
        expected_response['enabled_previews'] = ['CALC_XPATHS']
        self.assertJSONEqual(response.content, expected_response)
    def test_ambulance_get_viewset(self):
        # instantiate client
        client = Client()

        # login as admin
        client.login(username=settings.MQTT['USERNAME'],
                     password=settings.MQTT['PASSWORD'])

        # retrieve any ambulance
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a1.id)).data
        self.assertDictEqual(result, answer)

        # retrieve any ambulance
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a2.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a2.id)).data
        self.assertDictEqual(result, answer)

        # retrieve any ambulance
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data
        self.assertDictEqual(result, answer)

        # logout
        client.logout()

        # login as testuser2
        client.login(username='******', password='******')

        # retrieve own
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data
        self.assertDictEqual(result, answer)

        # retrieve someone else's
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a2.id)),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # can't read
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # logout
        client.logout()

        # login as testuser1
        client.login(username='******', password='******')

        # retrieve someone else's
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # retrieve someone else's
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a2.id)),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # logout
        client.logout()
    def test_ambulance_post_viewset(self):
        # instantiate client
        client = Client()

        # login as admin
        client.login(username=settings.MQTT['USERNAME'],
                     password=settings.MQTT['PASSWORD'])

        # create ambulance
        response = client.post(
            '/en/api/ambulance/', {
                'identifier': 'NEW-1897',
                'capability': AmbulanceCapability.R.name,
                'comment': 'no comments'
            })
        self.assertEqual(response.status_code, 201)
        a = Ambulance.objects.get(identifier='NEW-1897')

        # retrieve ambulance
        response = client.get('/en/api/ambulance/{}/'.format(str(a.id)))
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(a).data
        self.assertDictEqual(result, answer)

        # create ambulance (repeated identifier)
        response = client.post(
            '/en/api/ambulance/', {
                'identifier': 'NEW-1897',
                'capability': AmbulanceCapability.R.name,
                'comment': 'no comments'
            })
        self.assertEqual(response.status_code, 400)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertEqual(result['identifier'],
                         ['ambulance with this identifier already exists.'])

        # logout
        client.logout()

        # login as testuser2
        client.login(username='******', password='******')

        response = client.post(
            '/en/api/ambulance/', {
                'identifier': 'NEW-NEW-1897',
                'capability': AmbulanceCapability.B.name,
                'comment': 'more comments'
            })
        self.assertEqual(response.status_code, 403)

        # logout
        client.logout()

        # login as testuser1
        client.login(username='******', password='******')

        response = client.post(
            '/en/api/ambulance/', {
                'identifier': 'NEW-NEW-1897',
                'capability': AmbulanceCapability.B.name,
                'comment': 'more comments'
            })
        self.assertEqual(response.status_code, 403)

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

        # Bulk update ambulance a1
        a = self.a1
        user = self.u1

        location0 = {'latitude': -3., 'longitude': 6.}
        location = {'latitude': -2., 'longitude': 7.}
        orientation = calculate_orientation(dict2point(location0),
                                            dict2point(location))
        data = [{
            'status': AmbulanceStatus.AH.name,
            'location': location0,
        }, {
            'location': location,
            'timestamp': timezone.now()
        }, {
            'status': AmbulanceStatus.OS.name
        }]

        serializer = AmbulanceUpdateSerializer(data=data,
                                               many=True,
                                               partial=True)
        serializer.is_valid(raise_exception=True)
        serializer.save(ambulance=Ambulance.objects.get(id=a.id),
                        updated_by=user)

        # test AmbulanceUpdateSerializer
        queryset = AmbulanceUpdate.objects.filter(ambulance=a)
        answer1 = []
        for u in queryset:
            serializer = AmbulanceUpdateSerializer(u)
            result = {
                'id': u.id,
                'ambulance_id': u.ambulance.id,
                'ambulance_identifier': u.ambulance.identifier,
                'comment': u.comment,
                'capability': u.capability,
                'status': u.status,
                'orientation': u.orientation,
                'location': point2str(u.location),
                'timestamp': date2iso(u.timestamp),
                'updated_by_username': u.updated_by.username,
                'updated_on': date2iso(u.updated_on)
            }
            answer1.append(serializer.data)
            self.assertDictEqual(serializer.data, result)

        # make sure last update is reflected in ambulance
        a = Ambulance.objects.get(id=a.id)
        serializer = AmbulanceSerializer(a)
        self.assertEqual(math.fabs(orientation - a.orientation) < 1e-4, True)
        orientation = a.orientation
        result = {
            'id': a.id,
            'identifier': a.identifier,
            'comment': a.comment,
            'capability': a.capability,
            'status': AmbulanceStatus.OS.name,
            'orientation': orientation,
            'location': point2str(location),
            'timestamp': date2iso(a.timestamp),
            'client_id': None,
            'updated_by': a.updated_by.id,
            'updated_on': date2iso(a.updated_on)
        }
        self.assertDictEqual(serializer.data, result)

        # Bulk update ambulance a2
        a = self.a3
        user = self.u3

        data = [{
            'status': AmbulanceStatus.AH.name,
            'location': location0
        }, {
            'status': AmbulanceStatus.OS.name
        }, {
            'location': location,
            'timestamp': timezone.now()
        }]

        serializer = AmbulanceUpdateSerializer(data=data,
                                               many=True,
                                               partial=True)
        serializer.is_valid(raise_exception=True)
        serializer.save(ambulance=Ambulance.objects.get(id=a.id),
                        updated_by=user)

        # test AmbulanceUpdateSerializer
        queryset = AmbulanceUpdate.objects.filter(ambulance=a)
        answer3 = []
        for u in queryset:
            serializer = AmbulanceUpdateSerializer(u)
            result = {
                'id': u.id,
                'ambulance_id': a.id,
                'ambulance_identifier': a.identifier,
                'comment': u.comment,
                'capability': u.capability,
                'status': u.status,
                'orientation': u.orientation,
                'location': point2str(u.location),
                'timestamp': date2iso(u.timestamp),
                'updated_by_username': u.updated_by.username,
                'updated_on': date2iso(u.updated_on)
            }
            answer3.append(serializer.data)
            self.assertDictEqual(serializer.data, result)

        # make sure last update is reflected in ambulance
        a = Ambulance.objects.get(id=a.id)
        serializer = AmbulanceSerializer(a)
        self.assertEqual(math.fabs(orientation - a.orientation) < 1e-4, True)
        orientation = a.orientation
        result = {
            'id': a.id,
            'identifier': a.identifier,
            'comment': a.comment,
            'capability': a.capability,
            'status': AmbulanceStatus.OS.name,
            'orientation': orientation,
            'location': point2str(location),
            'timestamp': date2iso(a.timestamp),
            'client_id': None,
            'updated_by': a.updated_by.id,
            'updated_on': date2iso(a.updated_on)
        }
        self.assertDictEqual(serializer.data, result)

        # Test api

        # instantiate client
        client = Client()

        # login as admin
        client.login(username=settings.MQTT['USERNAME'],
                     password=settings.MQTT['PASSWORD'])

        # retrieve ambulances updates
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a1.id),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertCountEqual(result, answer1)
        self.assertEqual(len(result), 4)

        # retrieve ambulances updates
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a3.id),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertCountEqual(result, answer3)
        self.assertEqual(len(result), 4)

        # logout
        client.logout()

        # login as testuser1
        client.login(username='******', password='******')

        # retrieve ambulances
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a1.id),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # retrieve ambulances
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a3.id),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # logout
        client.logout()

        # login as testuser2
        client.login(username='******', password='******')

        # retrieve ambulances
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a1.id),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # retrieve ambulances updates
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a3.id),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertCountEqual(result, answer3)
        self.assertEqual(len(result), 4)

        # logout
        client.logout()
Beispiel #35
0
class ImageRepoTestCase(TestCase):
    def setUp(self):
        """Set up tests by creating an signing in a user and getting an image"""
        # create a temp dir to upload images
        settings.MEDIA_ROOT = tempfile.mkdtemp()
        # upload images to a temp dir for tests
        Image.image.field.storage = FileSystemStorage(
            location=settings.MEDIA_ROOT)
        self.client = Client()
        self.user1 = User.objects.create_user(username='******',
                                              password='******')
        self.client.login(username='******', password='******')
        with open('image_repo/test_data/test.png', 'rb') as file:
            self.upload_image = SimpleUploadedFile('test.png', file.read())

    def tearDown(self):
        """Clean up resources from setup and tests"""
        # remove temp dir for uploaded images
        shutil.rmtree(settings.MEDIA_ROOT)

    # MODELS
    def test_save_image(self):
        """Test if uploaded image path is correct (models.save_image())"""
        new_img = Image.objects.create(image=self.upload_image,
                                       user=self.user1)
        self.assertEqual(new_img.image.url, '/user1/test.png')

    def test_image_create(self):
        """Test if Image instance is created (models.Image())"""
        new_img = Image.objects.create(image=self.upload_image,
                                       user=self.user1)
        new_img.save()
        self.assertIsInstance(new_img, Image)

    # FORMS
    def test_image_form(self):
        """Test if image form is valid (forms.ImageForm())"""
        form_data = {'image': self.upload_image}
        form = ImageForm(files=form_data)
        self.assertTrue(form.is_valid())

    # VIEWS
    # sign up
    def test_sign_up_success_view(self):
        """Test if user signed up successfully (views.user_sign_up())"""
        self.client.logout()
        # use valid username and password
        resp = self.client.post(
            reverse('signup'), {
                'username': '******',
                'password1': 'Newuserpass',
                'password2': 'Newuserpass'
            })
        # make sure user is redirected to repo
        self.assertEqual(resp.status_code, 302)
        self.assertRedirects(resp, reverse('repo'))

    def test_sign_up_fail_view(self):
        """Test if user couldn't sign up (views.user_sign_up())"""
        self.client.logout()
        # use invalid password (too short)
        resp = self.client.post(reverse('signup'), {
            'username': '******',
            'password1': 'pass',
            'password2': 'pass'
        })
        self.assertEqual(resp.status_code, 401)
        self.assertEqual(
            resp.context['error'],
            'Invalid username or password. Please choose another one.')
        # use invalid username (with '!')
        resp = self.client.post(
            reverse('signup'), {
                'username': '******',
                'password1': 'Password',
                'password2': 'Password'
            })
        self.assertEqual(resp.status_code, 401)
        self.assertEqual(
            resp.context['error'],
            'Invalid username or password. Please choose another one.')
        # user different passwords
        resp = self.client.post(reverse('signup'), {
            'username': '******',
            'password1': 'pass1',
            'password2': 'pass2'
        })
        self.assertEqual(resp.status_code, 401)
        self.assertEqual(resp.context['error'], 'Passwords do not match.')
        # user already exists
        resp = self.client.post(
            reverse('signup'), {
                'username': '******',
                'password1': 'user1Pass',
                'password2': 'user1Pass'
            })
        self.assertEqual(resp.status_code, 401)
        self.assertEqual(
            resp.context['error'],
            'Username is already used. Please choose another one.')

    # sign in
    def test_sign_in_success_view(self):
        """Test if user signed in successfully (views.user_sign_in())"""
        self.client.logout()
        # existing user credentials (from setUp())
        resp = self.client.post(reverse('signin'), {
            'username': '******',
            'password': '******'
        })
        # make sure user is redirected to repo
        self.assertEqual(resp.status_code, 302)
        self.assertRedirects(resp, reverse('repo'))

    def test_sign_in_fail_view(self):
        """Test if user couldn't sign in (views.user_sign_in())"""
        self.client.logout()
        # non existing user credentials
        resp = self.client.post(reverse('signin'), {
            'username': '******',
            'password': '******'
        })
        self.assertEqual(resp.status_code, 401)
        self.assertEqual(resp.context['error'],
                         'Given username or password is incorrect.')

    # repo
    def test_redirect_unauth_view(self):
        """Test if unauthenticated user is redirected from views.repo()"""
        self.client.logout()
        resp = self.client.get(reverse('repo'))
        self.assertRedirects(resp, '/?next=/repo/')

    def test_auth_view(self):
        """Test if authenticated user can see views.repo()"""
        resp = self.client.get(reverse('repo'))
        self.assertEqual(resp.status_code, 200)
        self.assertTemplateUsed(resp, 'image_repo/repo.html')

    def test_auth_user_repo(self):
        """Test if user only sees their images (views.repo())"""
        # user1 uploads an image
        new_img = Image.objects.create(image=self.upload_image,
                                       user=self.user1)
        new_img.save()
        # check that user1 sees his data
        resp = self.client.get(reverse('repo'))
        # response context value of key 'images' (sent in views.repo())
        # should be the same as query set of user1
        self.assertQuerysetEqual(resp.context['images'],
                                 Image.objects.filter(user=self.user1))
        # create a second user who has no images
        self.client.logout()
        self.user2 = User.objects.create_user(username='******',
                                              password='******')
        self.client.login(username='******', password='******')
        # check that user2 sees only their data
        resp = self.client.get(reverse('repo'))
        self.assertQuerysetEqual(resp.context['images'],
                                 Image.objects.filter(user=self.user2))

    def test_image_upload(self):
        """Test if image gets uploaded in views.repo()"""
        resp = self.client.post(reverse('repo'),
                                data={'image': self.upload_image})
        self.assertEqual(resp.status_code, 200)
class ProfilePageTest(TestCase):
    fixtures = ['user']

    def setUp(self):
        self.client = Client()
        self.user = User.objects.get(id=1)
        self.client.force_login(self.user)

    def test_success_get(self):
        response = self.client.get('/auth/user_profile/')

        self.assertEqual(response.status_code, 200)
        self.assertIn('user_form', response.context)
        self.assertIn('profile_form', response.context)

    def test_success_post(self):
        response = self.client.post('/auth/user_profile/',
                                    data={
                                        'first_name': 'Elena',
                                        'last_name': 'Samoilenko'
                                    })

        self.user.refresh_from_db()
        self.assertRedirects(response, '/auth/user_profile/')
        self.assertEqual(self.user.first_name, 'Elena')
        self.assertEqual(self.user.last_name, 'Samoilenko')

    def test_anonymous_user(self):
        self.client.logout()
        response = self.client.get('/auth/user_profile/')
        self.assertRedirects(response, '/auth/login/?next=/auth/user_profile/')

    def test_create_family_get(self):
        response = self.client.get('/auth/create_family/')

        self.assertEqual(response.status_code, 200)
        self.assertIn('form', response.context)

    def test_create_family_anonymous_user(self):
        self.client.logout()
        response = self.client.get('/auth/user_profile/')
        self.assertRedirects(response, '/auth/login/?next=/auth/user_profile/')

    def test_create_family_post(self):
        response = self.client.post('/auth/create_family/',
                                    data={'last_name': 'Samoilenko'},
                                    follow=True)

        self.assertRedirects(response, '/auth/user_profile/')
        self.user.refresh_from_db()
        family = Family.objects.all().last()
        self.assertEqual(self.user.profile.family, family)
        self.assertTrue(self.user.profile.is_admin)
        self.assertContains(response, 'New Family was created.')

    def test_create_family_failed(self):
        family = Family.objects.create(last_name='Samoilenko')
        self.user.profile.family = family
        self.user.save()

        respose = self.client.post('/auth/create_family/',
                                   data={'last_name': 'TestTest'},
                                   follow=True)

        self.assertRedirects(respose, '/auth/user_profile/')
        self.assertContains(
            respose, 'ou cannot create new Family as you belong to one.')

    def test_generate_token(self):
        family = Family.objects.create(last_name='Samoilenko')
        self.user.profile.family = family
        self.user.profile.is_admin = True
        self.user.save()

        response = self.client.get('/auth/create_token/')

        self.assertEqual(response.status_code, 200)
        self.assertIsInstance(response.content, bytes)

    def test_generate_token_failed(self):
        response = self.client.get('/auth/create_token/', follow=True)

        self.assertRedirects(response, '/auth/user_profile/')
        self.assertContains(response,
                            'Just Family admins can create the token.')

        family = Family.objects.create(last_name='Samoilenko')
        self.user.profile.family = family
        self.user.save()

        response = self.client.get('/auth/create_token/', follow=True)

        self.assertRedirects(response, '/auth/user_profile/')
        self.assertContains(response,
                            'Just Family admins can create the token.')

    def test_generate_token_anonymous(self):
        self.client.logout()
        response = self.client.get('/auth/create_token/', follow=True)
        self.assertRedirects(response, '/auth/login/?next=/auth/create_token/')

    def test_connect_to_family_success(self):
        family = Family.objects.create(last_name='Samoilenko')
        token = family.generate_token()

        response = self.client.post('/auth/connect_to_family/',
                                    data={'token': token})
        self.assertRedirects(response, '/auth/user_profile/')
        self.user.refresh_from_db()
        self.assertEqual(self.user.profile.family, family)
        self.assertFalse(self.user.profile.is_admin)

    def test_connect_to_family_bag_token(self):
        response = self.client.post('/auth/connect_to_family/',
                                    data={},
                                    follow=True)
        self.assertRedirects(response, '/auth/user_profile/')
        self.assertContains(response, 'Token cannot be empty.')

        response = self.client.post('/auth/connect_to_family/',
                                    data={'token': 'sdfghjk'},
                                    follow=True)
        self.assertRedirects(response, '/auth/user_profile/')
        self.assertContains(response, 'Invalid token.')

        response = self.client.get('/auth/connect_to_family/')
        self.assertEqual(response.status_code, 405)

    def test_connect_to_family_have_family(self):
        family = Family.objects.create(last_name='Samoilenko')
        self.user.profile.family = family
        self.user.save()

        response = self.client.post('/auth/connect_to_family/',
                                    data={'token': family.generate_token()},
                                    follow=True)

        self.assertRedirects(response, '/auth/user_profile/')
        self.assertContains(response, 'You cannot connect to another family.')

    def test_leave_family_success(self):
        family = Family.objects.create(last_name='Samoilenko')
        self.user.profile.family = family
        self.user.save()

        response = self.client.get('/auth/leave_family/')
        self.assertRedirects(response, '/auth/user_profile/')

    def test_leave_family_anonymous(self):
        self.client.logout()
        response = self.client.get('/auth/leave_family/', follow=True)
        self.assertRedirects(response, '/auth/login/?next=/auth/leave_family/')

    def test_leave_family_no_family(self):
        response = self.client.get('/auth/leave_family/', follow=True)
        self.assertRedirects(response, '/auth/user_profile/')
        self.assertContains(response, 'You do not belong to the Family')

    def test_leave_family_admin(self):
        family = Family.objects.create(last_name='Samoilenko')
        self.user.profile.family = family
        self.user.profile.is_admin = True
        self.user.save()

        response = self.client.get('/auth/leave_family/', follow=True)
        self.assertRedirects(response, '/auth/user_profile/')
        self.assertContains(
            response, 'Admin cannot leave the Family. Set up new admin first.')
Beispiel #37
0
class ViewTest_Concordia(TestCase):
    """
    This class contains the unit tests for the view in the concordia app.

    Make sure the postgresql db is available. Run docker-compose up db
    """
    def setUp(self):
        """
        setUp is called before the execution of each test below
        :return:
        """

        # make sure the config-optional-override.json mode is "unittest"
        self.assertEqual(Config.GetOverrideMode(), 'unittest')

        self.client = Client()

    def login_user(self):
        """
        Create a user and log the user in
        :return:
        """
        # create user and login
        self.user = User.objects.create(username='******',
                                        email='*****@*****.**')
        self.user.set_password('top_secret')
        self.user.save()

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

    def test_concordia_api(self):
        """
        Test the tracribr_api. Provide a mock of requests
        :return:
        """

        # Arrange

        relative_path = Mock()

        with patch('views.requests') as mock_requests:
            mock_requests.get.return_value = mock_response = Mock()
            mock_response.status_code = 200
            mock_response.json.return_value = {'concordia_data': 'abc123456'}

            # Act
            results = views.concordia_api('relative_path')

            # Assert
            self.assertEqual(results['concordia_data'], 'abc123456')

    def test_AccountProfileView_get(self):
        """
        Test the http GET on route account/profile
        :return:
        """

        # Arrange

        self.login_user()

        # create a collection
        self.collection = Collection(title='TextCollection',
                                     slug='www.foo.com/slug2',
                                     description='Collection Description',
                                     metadata={"key": "val1"},
                                     status=Status.PCT_0)
        self.collection.save()

        # create an Asset
        self.asset = Asset(title='TestAsset',
                           slug='www.foo.com/slug1',
                           description='Asset Description',
                           media_url='http://www.foo.com/1/2/3',
                           media_type=MediaType.IMAGE,
                           collection=self.collection,
                           metadata={"key": "val2"},
                           status=Status.PCT_0)
        self.asset.save()

        # add a Transcription object
        self.transcription = Transcription(asset=self.asset,
                                           user_id=self.user.id,
                                           status=Status.PCT_0)
        self.transcription.save()

        # Act
        response = self.client.get('/account/profile/')

        # Assert

        # validate the web page has the "tester" and "*****@*****.**" as values
        self.assertTrue('value="tester"' in str(response.content))
        self.assertTrue('value="*****@*****.**"' in str(response.content))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, template_name='profile.html')

    def test_AccountProfileView_post(self):
        """
        This unit test tests the post entry for the route account/profile
        :param self:
        :return:
        """

        # Arrange
        self.login_user()

        # Act
        response = self.client.post(
            '/account/profile/', {
                'first_name': 'Jimmy',
                'email': '*****@*****.**',
                'username': '******',
                'password1': '',
                'password2': ''
            })

        # Assert
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, '/account/profile/')

        # Verify the User was correctly updated
        updated_user = User.objects.get(id=self.user.id)
        self.assertEqual(updated_user.first_name, 'Jimmy')

    def test_AccountProfileView_post_invalid_form(self):
        """
        This unit test tests the post entry for the route account/profile but submits an invalid form
        :param self:
        :return:
        """

        # Arrange
        self.login_user()

        # Act
        response = self.client.post('/account/profile/',
                                    {'first_name': 'Jimmy'})

        # Assert
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, '/account/profile/')

        # Verify the User was not changed
        updated_user = User.objects.get(id=self.user.id)
        self.assertEqual(updated_user.first_name, '')

    def test_AccountProfileView_post_new_password(self):
        """
        This unit test test the post entry for the route account/profile with new password
        :param self:
        :return:
        """

        # Arrange
        self.login_user()

        # Act
        response = self.client.post(
            '/account/profile/', {
                'first_name': 'Jimmy',
                'email': '*****@*****.**',
                'username': '******',
                'password1': 'abc',
                'password2': 'abc'
            })

        # Assert
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, '/account/profile/')

        # Verify the User was correctly updated
        updated_user = User.objects.get(id=self.user.id)
        self.assertEqual(updated_user.first_name, 'Jimmy')

        # logout and login with new password
        logout = self.client.logout()
        login2 = self.client.login(username='******', password='******')

        self.assertTrue(login2)

    def test_AccountProfileView_post_with_image(self):
        """
        This unit test tests the post entry for the route account/profile with new image file
        :param self:
        :return:
        """

        # Arrange
        self.login_user()

        existing_userprofile_count = UserProfile.objects.all().count()

        # Act
        image = Image.new('RGBA', size=(50, 50), color=(155, 0, 0))
        file = tempfile.NamedTemporaryFile(suffix='.png')
        image.save(file)

        with open(file.name, encoding="ISO-8859-1") as fp:

            response = self.client.post(
                '/account/profile/', {
                    'myfile': fp,
                    'first_name': 'Jimmy',
                    'email': '*****@*****.**',
                    'username': '******',
                    'password1': '',
                    'password2': ''
                })

            # Assert
            self.assertEqual(response.status_code, 302)
            self.assertEqual(response.url, '/account/profile/')

            # Verify the UserProfile was correctly updated, a new entry in db exists
            profile = UserProfile.objects.all()

            self.assertEqual(len(profile), existing_userprofile_count + 1)

    @patch('concordia.views.requests')
    def test_concordiaView(self, mock_requests):
        """
        Test the GET method for route /transcribe
        :return:
        """
        # Arrange

        mock_requests.get.return_value.status_code = 200
        mock_requests.get.return_value.json.return_value = {
            'concordia_data': 'abc123456'
        }

        # Act
        response = self.client.get('/transcribe/')

        # Assert
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response,
                                template_name='transcriptions/home.html')

    def test_concordiaCollectionView_get(self):
        """
        Test GET on route /transcribe/<slug-value> (collection)
        :return:
        """

        # Arrange

        # add an item to Collection
        self.collection = Collection(title='TextCollection',
                                     slug='test-slug2',
                                     description='Collection Description',
                                     metadata={"key": "val1"},
                                     status=Status.PCT_0)
        self.collection.save()

        # Act
        response = self.client.get('/transcribe/test-slug2/')

        # Assert
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response,
                                template_name='transcriptions/collection.html')

    def test_concordiaCollectionView_get_page2(self):
        """
        Test GET on route /transcribe/<slug-value>/ (collection) on page 2
        :return:
        """

        # Arrange

        # add an item to Collection
        self.collection = Collection(title='TextCollection',
                                     slug='test-slug2',
                                     description='Collection Description',
                                     metadata={"key": "val1"},
                                     status=Status.PCT_0)
        self.collection.save()

        # Act
        response = self.client.get('/transcribe/test-slug2/', {'page': 2})

        # Assert
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response,
                                template_name='transcriptions/collection.html')

    def test_ExportCollectionView_get(self):
        """
        Test GET route /transcribe/export/<slug-value>/ (collection)
        :return:
        """

        # Arrange

        self.collection = Collection(title='TextCollection',
                                     slug='slug2',
                                     description='Collection Description',
                                     metadata={"key": "val1"},
                                     status=Status.PCT_0)
        self.collection.save()

        self.asset = Asset(title='TestAsset',
                           slug='test-slug2',
                           description='Asset Description',
                           media_url='http://www.foo.com/1/2/3',
                           media_type=MediaType.IMAGE,
                           collection=self.collection,
                           metadata={"key": "val2"},
                           status=Status.PCT_0)
        self.asset.save()

        # Act
        response = self.client.get('/transcribe/export/slug2/')

        # Assert
        self.assertEqual(response.status_code, 200)
        self.assertEqual(
            str(response.content),
            "b'Collection,Title,Description,MediaUrl,Transcription,Tags\\r\\nTextCollection,TestAsset,Asset Description,http://www.foo.com/1/2/3,,\\r\\n\'"
        )

    def test_DeleteCollection_get(self):
        """
        Test GET route /transcribe/delete/<slug-value>/ (collection)
        :return:
        """

        # Arrange
        # add an item to Collection
        self.collection = Collection(title='TextCollection',
                                     slug='test-slug2',
                                     description='Collection Description',
                                     metadata={"key": "val1"},
                                     status=Status.PCT_0)
        self.collection.save()

        self.asset = Asset(title='TestAsset',
                           slug='test-slug2',
                           description='Asset Description',
                           media_url='http://www.foo.com/1/2/3',
                           media_type=MediaType.IMAGE,
                           collection=self.collection,
                           metadata={"key": "val2"},
                           status=Status.PCT_0)
        self.asset.save()

        # Act
        response = self.client.get('/transcribe/delete/test-slug2',
                                   follow=True)

        # Assert
        self.assertEqual(response.status_code, 200)

        # verify the collection is not in db
        collection2 = Collection.objects.all()
        self.assertEqual(len(collection2), 0)
Beispiel #38
0
class TestProfile(TestCase):
	def setUp(self):
		self.client = Client()

		self.user1 = User.objects.create(
			username='******',
			password='******',
			email='*****@*****.**')

		self.user2 = User.objects.create(
			username='******',
			email='*****@*****.**')

		self.user2.set_password('pass@123')
		self.user2.save()

		self.user2_profile = Profile.objects.create(
			user=self.user2,
			department='Computer Engineering',
			institute='ace',
			position='instructor',
			phone_number='1122993388',
			is_email_verified=1
			)

	def test_has_profile_for_user_without_profile(self):
		"""
		If no profile exists for user passed as argument return False
		"""
		has_profile_status = has_profile(self.user1)
		self.assertFalse(has_profile_status)

	def test_has_profile_for_user_with_profile(self):
		"""
		If profile exists for user passed as argument return True
		"""
		has_profile_status = has_profile(self.user2)
		self.assertTrue(has_profile_status)

	def test_view_profile_denies_anonymous(self):
		"""
		If not logged in redirect to login page
		"""
		response = self.client.get(reverse(view_profile), follow=True)
		redirect_destination = '/login/?next=/view_profile/'
		self.assertTrue(response.status_code,200)
		self.assertRedirects(response, redirect_destination)

	def test_edit_profile_get(self):
		"""
		GET request to edit profile should display profile form
		"""

		self.client.login(username=self.user2, password='******')
		response = self.client.get(reverse(edit_profile))
		user_profile = User.objects.get(id=self.user2.id)
		profile = Profile.objects.get(user=user_profile)
		self.assertEqual(response.status_code, 200)
		self.assertEqual(profile.institute, 'ace')
		self.client.logout()

	def test_edit_profile_post(self):

		self.client.login(username=self.user2, password='******')
		response = self.client.post('/edit_profile/',
			{
				'first_name': 'demo_test',
				'last_name': 'user2',
				'institute': 'IIT',
				'department': 'aerospace engineering'
					})
	
		updated_profile_user = User.objects.get(id=self.user2.id)
		updated_profile = Profile.objects.get(user=updated_profile_user)
		self.assertEqual(updated_profile.institute, 'IIT')
		self.assertEqual(updated_profile.department, 'aerospace engineering')
		self.assertEqual(updated_profile.position, 'instructor')
		self.assertEqual(response.status_code, 200)
		# self.assertTemplateUsed(response, 'workshop_app/profile_updated.html')

	def test_register_page(self):
		self.client.get('/register/')
		self.register_response = self.client.post('/register/',
			data={
			'username':'******',
			'email':'*****@*****.**',
			'password':'******',
			'confirm password':'******',
			'first name':'testor',
			'last name':'user',
			'phone number': 1234567890,
			'institute':'IIT',
			'department':(2)})

		self.assertEqual(self.register_response.status_code,200)
Beispiel #39
0
class TemplateTestCase(TestCase):
    def setUp(self):
        self.client = Client()

        devGroup = Group.objects.create(name='Developer')
        cusGroup = Group.objects.create(name='Customer')

        userDeveloper = User.objects.create_user('developer',
                                                 '*****@*****.**',
                                                 'developer')
        userCustomer = User.objects.create_user('customer',
                                                '*****@*****.**',
                                                'customer')

        devProfile = UserProfile.objects.create(user=userDeveloper,
                                                isDeveloper=True,
                                                username='******')
        UserProfile.objects.create(user=userCustomer,
                                   isDeveloper=False,
                                   username='******')

        Game.objects.create(name='Test Game',
                            price=0.99,
                            url='www.google.fi',
                            published=timezone.now(),
                            description='Test Description',
                            developer=devProfile)

        devGroup.user_set.add(userDeveloper)
        cusGroup.user_set.add(userCustomer)

    def testLogin(self):
        """ Check that temp users work """

        self.client.login(username='******', password='******')
        devUser = User.objects.get(username='******')
        profile = UserProfile.objects.get(user=devUser)
        print('\nDeveloper correctly set up:', end=" ")
        print(profile.isDeveloper)
        self.client.logout()

    def testInvalidUrls(self):
        """ Test for invalid urls """
        print('Testing invalid urls')

        res = self.client.get('/game/xx')
        self.assertEquals(res.status_code, 404,
                          "Requesting a game page with an invalid code.")

        res = self.client.get('/dev/xx')
        self.assertEquals(res.status_code, 404,
                          "Requesting a developer page with an invalid code.")

        res = self.client.get('/dev/game/xx')
        self.assertEquals(
            res.status_code, 404,
            "Requesting a game editing page with an invalid code.")

        res = self.client.get('/xx')
        self.assertEquals(res.status_code, 404,
                          "Requesting a page with an invalid code.")

    def testGameMenu(self):
        """ Tests that the game list is rendered correctly """
        print('Testing gamelist')

        all_games = ({
            'name': 'testGame',
            'description': 'testScription',
            'price': 0.99
        }, {
            'name': 'bestGame',
            'description': 'badScription',
            'price': 1.99
        })
        ren = render_to_string("webshop/gamelist.html",
                               {'all_games': all_games})
        for game in all_games:
            self.assertTrue(
                ren.find(game['name']) > -1,
                "Testing if the rendered menu contains correct game name")
            self.assertTrue(
                ren.find(game['description']) > -1,
                "Testing if the rendered menu contains correct game description"
            )
            self.assertTrue(
                ren.find(str(game['price'])) > -1,
                "Testing if the rendered menu contains correct game price")

    def testBuyGame(self):
        """ Test buying game by accessing /buy/success """
        print('\nTesting access to /buy/success')

        # No user
        self.client.logout()
        res = self.client.get('/buy/success/1')
        self.assertTemplateUsed(res, 'webshop/buy_error.html')

        # With user
        self.client.login(username='******', password='******')
        res = self.client.get('/buy/success/1')
        self.assertTemplateUsed(res, 'webshop/buy_error.html')
        self.client.logout()
Beispiel #40
0
class FollowAndCommentView(TestCase):
    def setUp(self):
        self.client = Client()

        self.user_follower = User.objects.create_user(username='******',
                                                      password='******')
        self.client.force_login(self.user_follower)

        self.user_wo_subscribe = User.objects.create_user(
            username='******', password='******')
        self.user_for_subscribe = User.objects.create_user(
            username='******', password='******')

        self.group = Group.objects.create(title='test_group',
                                          slug='test_group',
                                          description='test_group')

    def test_user_subscribe_and_unsubscribe_author(self):
        self.client.post(
            reverse('profile_follow',
                    kwargs={'username': self.user_for_subscribe}))
        self.assertEquals(Follow.objects.count(), 1)

        subscribed_author = Follow.objects.get(user=self.user_follower)
        self.assertEquals(subscribed_author.author, self.user_for_subscribe)

    def test_user_unsubscribe_author(self):
        self.client.post(
            reverse('profile_follow',
                    kwargs={'username': self.user_for_subscribe}))
        self.assertEquals(Follow.objects.count(), 1)

        self.client.post(
            reverse('profile_unfollow',
                    kwargs={'username': self.user_for_subscribe}))
        self.assertEquals(Follow.objects.count(), 0)

    @override_settings(CACHES=DUMMY_CACHE)
    def test_posts_subscribed_user(self):
        text = 'following_text'
        self.client.force_login(self.user_for_subscribe)
        self.client.post(reverse('new_post'),
                         data={
                             'group': self.group.id,
                             'text': text
                         },
                         follow=True)

        self.client.force_login(self.user_follower)
        self.client.post(
            reverse('profile_follow',
                    kwargs={'username': self.user_for_subscribe}))
        resp_subscribed = self.client.get(reverse('follow_index'))
        self.assertEquals(resp_subscribed.context['paginator'].count, 1)
        self.assertContains(resp_subscribed, text)

    def test_nonsubscribed_user_posts(self):
        text = 'following_text'
        self.client.force_login(self.user_for_subscribe)
        self.client.post(reverse('new_post'),
                         data={
                             'group': self.group.id,
                             'text': text
                         },
                         follow=True)

        self.client.force_login(self.user_wo_subscribe)
        resp_nonsubscribed = self.client.get(reverse('follow_index'))
        self.assertEquals(resp_nonsubscribed.context['paginator'].count, 0)

    def test_subscribe_by_itself(self):
        resp_tag = self.client.get(
            reverse('profile',
                    kwargs={'username': self.user_follower.username}))
        self.assertNotContains(resp_tag, 'Подписаться')
        self.assertNotContains(resp_tag, 'Отписаться')

    def test_auth_user_add_comment(self):
        text_comment = 'text for comment'
        text = 'following_text'
        self.client.force_login(self.user_for_subscribe)
        self.client.post(reverse('new_post'),
                         data={
                             'group': self.group.id,
                             'text': text
                         },
                         follow=True)

        self.client.force_login(self.user_follower)
        post = Post.objects.get(author=self.user_for_subscribe)
        self.client.post(reverse('add_comment',
                                 kwargs={
                                     'username': self.user_for_subscribe,
                                     'post_id': post.id
                                 }),
                         data={'text': text_comment},
                         follow=True)

        comment = Comment.objects.get(author=self.user_follower)

        self.assertEquals(Comment.objects.count(), 1)
        self.assertEquals(comment.text, text_comment)
        self.assertEquals(comment.post.text, post.text)

        resp = self.client.get(
            reverse('post',
                    kwargs={
                        'username': self.user_for_subscribe,
                        'post_id': post.id
                    }))
        self.assertEquals(resp.context['comments'][0].text, text_comment)

    def test_non_auth_user_add_comment(self):
        text = 'following_text'
        self.client.force_login(self.user_for_subscribe)
        self.client.post(reverse('new_post'),
                         data={
                             'group': self.group.id,
                             'text': text
                         },
                         follow=True)

        self.client.logout()
        text_comment = 'text for comment'
        post = Post.objects.get(author=self.user_for_subscribe)
        self.client.post(reverse('add_comment',
                                 kwargs={
                                     'username': self.user_for_subscribe,
                                     'post_id': post.id
                                 }),
                         data={'text': text_comment},
                         follow=True)

        comments_count = Comment.objects.count()
        self.assertEquals(comments_count, 0)
Beispiel #41
0
class AuthUserPostView(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(username='******', password='******')
        self.client.force_login(self.user)

        self.group = Group.objects.create(title='test_group',
                                          slug='test_group',
                                          description='test_group')

    def test_create_new_user_and_profile(self):
        resp = self.client.get(
            reverse('profile', kwargs={'username': self.user.username}))
        self.assertEqual(resp.status_code, 200)
        self.assertTemplateUsed(resp, 'profile.html')

    def test_logged_user_make_create_post(self):
        text = 'text for post'
        self.client.post(reverse('new_post'),
                         data={
                             'group': self.group.id,
                             'text': text
                         },
                         follow=True)
        post = Post.objects.first()
        self.assertEquals(Post.objects.count(), 1)
        self.assertEquals(post.author, self.user)
        self.assertEquals(post.group, self.group)
        self.assertEquals(post.text, text)

    def test_view_post_on_all_templates(self):
        text = 'text for post'
        self.post = Post.objects.create(author=self.user,
                                        group=self.group,
                                        text=text)

        urls = [
            reverse('index'),
            reverse('profile', kwargs={'username': self.user.username}),
            reverse('post',
                    kwargs={
                        'username': self.user.username,
                        'post_id': self.post.id
                    }),
            reverse('group', kwargs={'slug': self.group.slug})
        ]

        for url in urls:
            with self.subTest(url=url):
                self.check_post_on_templates(url=url,
                                             author=self.user,
                                             group=self.group,
                                             text=text)

    def test_logged_user_edit_post(self):
        text = 'text for post'
        new_text = 'new text'
        new_group = Group.objects.create(title='new_group',
                                         slug='new_group',
                                         description='new_group')
        self.post = Post.objects.create(author=self.user,
                                        group=self.group,
                                        text=text)

        self.client.post(reverse('post_edit',
                                 kwargs={
                                     'username': self.user,
                                     'post_id': self.post.id
                                 }),
                         data={
                             'group': new_group.id,
                             'text': new_text
                         },
                         follow=True)
        resp_old_group = self.client.get(
            reverse('group', kwargs={'slug': self.group}))
        self.assertEquals(resp_old_group.context['paginator'].count, 0)

        urls = [
            reverse('index'),
            reverse('profile', kwargs={'username': self.user.username}),
            reverse('post',
                    kwargs={
                        'username': self.user.username,
                        'post_id': self.post.id
                    }),
            reverse('group', kwargs={'slug': new_group.slug})
        ]

        for url in urls:
            with self.subTest(url=url):
                self.check_post_on_templates(url=url,
                                             author=self.user,
                                             group=new_group,
                                             text=new_text)

    def check_post_on_templates(self, url, author, group, text):
        resp = self.client.get(url)
        if 'paginator' in resp.context:
            self.assertEquals(resp.context['paginator'].count, 1)
            post = resp.context['page'][0]
        else:
            post = resp.context['post']
        self.assertEquals(post.text, text)
        self.assertEquals(post.author, author)
        self.assertEquals(post.group, group)

    def test_redirect_if_not_logged_user_try_create_post(self):
        self.client.logout()
        resp = self.client.get(reverse('new_post'), follow=True)
        self.assertRedirects(resp, '/auth/login/?next=/new/')

    def test_error_404(self):
        resp = self.client.get('/404/')
        self.assertEquals(resp.status_code, 404)
        self.assertTemplateUsed(resp, 'misc/404.html')

    @override_settings(CACHES=DUMMY_CACHE)
    def test_tag_on_post_template(self):
        io_image = BytesIO()
        generated_image = Image.new(mode='RGBA', size=(100, 100))
        generated_image.save(io_image, 'png')
        io_image.seek(0)

        data = {
            'group': self.group.id,
            'text': 'new_text',
            'image': ImageFile(io_image, 'image.png')
        }
        self.client.post(reverse('new_post'), data=data, follow=True)

        urls = [
            reverse('index'),
            reverse('post',
                    kwargs={
                        'username': self.user.username,
                        'post_id': 1
                    }),
            reverse('profile', kwargs={'username': self.user.username}),
            reverse('group', kwargs={'slug': self.group.slug})
        ]

        for url in urls:
            with self.subTest(url=url):
                resp = self.client.get(url)
                self.assertContains(resp, '<img')

    def test_form_image_field_validation(self):
        txt_file = SimpleUploadedFile('file.txt', b'text_file')
        resp = self.client.post(reverse('new_post'),
                                data={
                                    'group': self.group.id,
                                    'image': txt_file
                                },
                                follow=True)
        error = 'Загрузите правильное изображение. Файл, который вы загрузили, поврежден или не является изображением.'
        self.assertFormError(resp, 'form', 'image', error)

    def test_cache_index_posts(self):
        text_new_post = 'text for post'
        text_after_edit = 'new text'

        post = Post.objects.create(author=self.user,
                                   group=self.group,
                                   text=text_new_post)
        self.check_version_template_in_cache(text=text_new_post)

        self.client.post(reverse('post_edit',
                                 kwargs={
                                     'username': self.user,
                                     'post_id': post.id
                                 }),
                         data={
                             'group': self.group.id,
                             'text': text_after_edit
                         },
                         follow=True)
        self.check_version_template_in_cache(text=text_new_post)

        response = self.client.get(reverse('index'))
        key = make_template_fragment_key('index_page',
                                         [response.context['page'].number])
        cache.delete(key)
        self.check_version_template_in_cache(text=text_after_edit)

    def check_version_template_in_cache(self, text):
        resp = self.client.get(reverse('index'))
        self.assertContains(resp, text)
Beispiel #42
0
class TicketViewsTestCase(TestCase):
    def setUp(self):
        self.client = Client()

        self.plane = Plane.objects.create(name="A333")
        self.flight = Flight.objects.create(departure_time=timezone.now(),
                                            flight_id="AV 2341",
                                            country="Russia",
                                            city="Moscow",
                                            arrival_time=timezone.now(),
                                            company="S7",
                                            plane_name=self.plane,
                                            status="Registration")
        self.user = User.objects.create_user(username='******',
                                             password='******')
        self.ticket = Ticket.objects.create(user=self.user, flight=self.flight)
        self.client.login(username='******', password='******')

    def test_flight_ticket_GET(self):
        response = self.client.get(
            reverse('flight_ticket_url', kwargs={'slug': self.flight.slug}))

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, 'crm/ticket_booking.html')

    def test_flight_ticket_GET_flight_not_flight(self):
        response = self.client.get(
            reverse('flight_ticket_url', kwargs={'slug': 'test_slug'}))

        self.assertEqual(response.status_code, 404)

    def test_flight_ticket_GET_without_slug(self):
        response = self.client.get(
            reverse('flight_ticket_url', kwargs={'slug': None}))

        self.assertEqual(response.status_code, 404)

    def test_flight_ticket_POST(self):
        response = self.client.post(
            reverse('flight_ticket_url', kwargs={'slug': self.flight.slug}))
        posted_ticket = Ticket.objects.all()[1]

        self.assertEqual(response.status_code, 302)
        self.assertEqual(posted_ticket.user, self.user)
        self.assertEqual(posted_ticket.flight, self.flight)

    def test_flight_ticket_POST_flight_not_found(self):
        response = self.client.post(
            reverse('flight_ticket_url', kwargs={'slug': 'test_slug'}))

        self.assertEqual(response.status_code, 404)

    def test_flight_ticket_POST_without_slug(self):
        response = self.client.post(
            reverse('flight_ticket_url', kwargs={'slug': None}))

        self.assertEqual(response.status_code, 404)

    def test_flight_ticket_POST_as_anonymous_user(self):
        self.client.logout()
        response = self.client.post(
            reverse('flight_ticket_url', kwargs={'slug': self.flight.slug}))

        self.assertEqual(response.status_code, 400)

    def test_flight_ticket_delete_GET(self):
        response = self.client.get(
            reverse('flight_ticket_delete_url',
                    kwargs={'slug': self.flight.slug}))

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, 'crm/ticket_delete.html')

    def test_flight_ticket_delete_GET_flight_not_found(self):
        response = self.client.get(
            reverse('flight_ticket_delete_url', kwargs={'slug': 'test_slug'}))

        self.assertEqual(response.status_code, 404)

    def test_flight_ticket_delete_GET_without_slug(self):
        response = self.client.get(
            reverse('flight_ticket_delete_url', kwargs={'slug': None}))

        self.assertEqual(response.status_code, 404)

    def test_flight_ticket_delete_POST(self):
        response = self.client.post(
            reverse('flight_ticket_delete_url',
                    kwargs={'slug': self.flight.slug}))

        tickets_count = Ticket.objects.all().count()

        self.assertEqual(response.status_code, 302)
        self.assertEqual(tickets_count, 0)

    def test_flight_ticket_delete_POST_flight_not_found(self):
        response = self.client.post(
            reverse('flight_ticket_delete_url', kwargs={'slug': 'test_slug'}))

        self.assertEqual(response.status_code, 404)

    def test_flight_ticket_delete_POST_without_slug(self):
        response = self.client.post(
            reverse('flight_ticket_delete_url', kwargs={'slug': None}))

        self.assertEqual(response.status_code, 404)

    def test_flight_ticket_delete_POST_as_anonymous_user(self):
        self.client.logout()
        response = self.client.post(
            reverse('flight_ticket_delete_url',
                    kwargs={'slug': self.flight.slug}))

        self.assertEqual(response.status_code, 400)

    def test_my_tickets_GET(self):
        response = self.client.get(reverse('my_tickets_url'))

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, 'crm/my_tickets.html')

    def test_my_tickets_GET_as_anonymous_user(self):
        self.client.logout()
        response = self.client.get(reverse('my_tickets_url'))

        self.assertEqual(response.status_code, 400)
Beispiel #43
0
class PluginsMenuTest(TestCase):

    def setUp(self):
        self.user = self.create_user()
        self.client = Client()
        cache.clear()

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

    def create_user(self):
        user = User()
        user.username = "******"
        user.set_password("123colab4")
        user.email = "*****@*****.**"
        user.id = 1
        user.first_name = "USERtestCoLaB"
        user.last_name = "COLAB"
        user.save()

        return user

    def authenticate_user(self):
        self.client.login(username=self.user.username,
                          password="******")

    def test_plugins_menu_without_menu_urls(self):
        self.authenticate_user()
        plugin_1 = {'menu_title': 'myTitle', 'menu_urls': []}

        test_context = {'user': self.user,
                        'plugins': {'plugin_1': plugin_1}}

        menu = plugins.plugins_menu(test_context)

        self.assertEquals(menu.strip(), "")

    def test_plugins_menu_with_1_menu_urls(self):
        self.authenticate_user()
        link = 'http://url'
        title = 'myTitle'
        plugin_1 = {'menu_title': title,
                    'menu_urls': [{'url': link, 'display': 'LRU'}]}

        test_context = {'user': self.user,
                        'plugins': {'plugin_1': plugin_1}}

        menu = plugins.plugins_menu(test_context)

        self.assertIn(link, menu)
        self.assertIn(title, menu)

    def test_plugins_menu_with_many_menu_urls(self):
        self.authenticate_user()

        link1 = 'http://url1'
        title1 = 'myTitle1'
        display1 = 'LRU1'
        link2 = 'http://url2'
        display2 = 'LRU2'

        plugin_1 = {'menu_title': title1,
                    'menu_urls': [{'url': link1, 'display': display1},
                                  {'url': link2, 'display': display2}]}

        test_context = {'user': self.user,
                        'plugins': {'plugin_1': plugin_1}}

        menu = plugins.plugins_menu(test_context)

        self.assertIn(link1, menu)
        self.assertIn(title1, menu)
        self.assertIn(display1, menu)
        self.assertIn(link2, menu)
        self.assertIn(display2, menu)

    def test_plugins_menu_with_multiple_plugins(self):
        self.authenticate_user()

        link1 = 'http://url1'
        title1 = 'myTitle1'
        display1 = 'LRU1'
        link2 = 'http://url2'
        display2 = 'LRU2'

        plugin_1 = {'menu_title': title1,
                    'menu_urls': [{'url': link1, 'display': display1},
                                  {'url': link2, 'display': display2}]}

        title2 = 'myTitle2'
        plugin_2 = {'menu_title': title2,
                    'menu_urls': []}

        test_context = {'user': self.user,
                        'plugins': {'plugin_1': plugin_1,
                                    'plugin_2': plugin_2}}

        menu = plugins.plugins_menu(test_context)

        self.assertIn(link1, menu)
        self.assertIn(title1, menu)
        self.assertIn(display1, menu)
        self.assertIn(link2, menu)
        self.assertIn(display2, menu)
        self.assertNotIn(title2, menu)

    class ColabUrlMock(Mock):
        def auth(self):
            return True

    def test_plugins_menu_with_inactivate_user(self):
        self.user.is_active = False
        self.user.save()

        self.authenticate_user()
        title = 'myTitle'
        plugin_1 = {'menu_title': title,
                    'menu_urls': [self.ColabUrlMock()]}

        test_context = {'user': self.user,
                        'plugins': {'plugin_1': plugin_1}}

        menu = plugins.plugins_menu(test_context)

        self.assertEquals("", menu.strip())
Beispiel #44
0
class PageTest(TestCase, CommonFunc):
    def setUp(self):
        self.user = User.objects.create_user(username="******")
        self.auth_client = Client()
        self.auth_client.force_login(self.user)

        self.non_auth_client = Client()
        self.group = Group.objects.create(
            title="test group", slug="test-slug", description="description",
        )

    def test_client_page(self):
        """
        Тест проверяет, что осле регистрации пользователя создается
        его персональная страница (profile)
        """
        response = self.auth_client.get(
            reverse("profile", kwargs={"username": self.user.username})
        )
        self.assertEqual(response.status_code, 200, "Страница пользователя не найдена!")

    def test_create_post_by_auth_user(self):
        """
        Тест проверяет, что авторизованный
        пользователь может опубликовать пост (new)
        """
        response = self.auth_client.post(
            reverse("new_post"),
            data={"group": self.group.id, "text": "test"},
            follow=True,
        )
        self.assertEqual(response.status_code, 200, "Ошибка создания поста!")
        created_post = Post.objects.all().first()
        self.assertEqual(Post.objects.count(), 1)
        self.assertEqual(created_post.group, self.group)
        self.assertEqual(created_post.author, self.user)
        self.assertEqual(created_post.text, "test")

    def test_create_post_by_non_auth_user(self):
        """
        Тест проверяет, что НЕ авторизованный
        пользователь НЕ может опубликовать пост (new)
        """
        self.non_auth_client.logout()
        response = self.non_auth_client.get(reverse("new_post"))
        self.assertRedirects(
            response,
            "/auth/login/?next=/new/",
            msg_prefix="Не авторизованный пользователь"
            "не переадресовывается на страницу "
            "входа (login)!",
        )

    def test_post_exists_on_pages(self):
        """
        Тест создает пост и проверяет его отображение по всем страницам из
        спискка urls_list
        """
        text = "text in test post"
        post = Post.objects.create(text=text, author=self.user, group=self.group)

        urls_list = [
            reverse("index"),
            reverse("profile", kwargs={"username": self.user.username}),
            reverse(
                "post", kwargs={"username": self.user.username, "post_id": post.id}
            ),
        ]

        for url in urls_list:
            with self.subTest(url=url):
                self.check_post_on_page(
                    self.auth_client, url, text, self.user, self.group
                )

    def test_auth_user_can_edit_own_post(self):
        """
        Тест проверяет, что авторизованный пользователь может отредактировать
        свой пост и его содержимое изменится на всех связанных страницах
        """
        post = Post.objects.create(
            text="old text in post", author=self.user, group=self.group
        )

        edit_urls_list = [
            reverse("index"),
            reverse("profile", kwargs={"username": self.user.username}),
            reverse(
                "post", kwargs={"username": self.user.username, "post_id": post.id}
            ),
        ]
        new_text = "This is text after edit."
        response = self.auth_client.post(
            reverse(
                "post_edit", kwargs={"post_id": post.id, "username": self.user.username}
            ),
            data={"group": self.group.id, "text": new_text},
            follow=True,
        )
        self.assertEqual(response.status_code, 200)
        for url in edit_urls_list:
            with self.subTest(url=url):
                self.check_post_on_page(
                    self.auth_client, url, new_text, self.user, self.group
                )

    def test_404(self):
        response = self.auth_client.get("/unknown/")
        self.assertEqual(
            response.status_code,
            404,
            "Страница '/unknown/' существует "
            " проверьте ошибку 404 на другой странице!",
        )

    def _create_image(self):
        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
            image = Image.new("RGB", (200, 200), "white")
            image.save(f, "PNG")
        return open(f.name, mode="rb")

    def test_image(self):
        post = Post.objects.create(
            text="post with image", author=self.user, group=self.group
        )
        img_urls_list = [
            reverse("index"),
            reverse("profile", kwargs={"username": self.user.username}),
            reverse(
                "post", kwargs={"username": self.user.username, "post_id": post.id}
            ),
            reverse("group", kwargs={"slug": self.group.slug}),
        ]
        img = self._create_image()
        response = self.auth_client.post(
            reverse(
                "post_edit",
                kwargs={"post_id": post.id, "username": self.user.username},
            ),
            data={"group": self.group.id, "text": "post with image", "image": img},
            follow=True,
        )
        self.assertEqual(response.status_code, 200, "Ошибка добавления картинки!")
        for url in img_urls_list:
            with self.subTest(url=url):
                response = self.auth_client.get(url)
                self.assertEqual(
                    response.status_code, 200, "Не найдена страница с картинкой!"
                )
                self.assertContains(response, "<img")

    def test_wrong_image(self):
        post = Post.objects.create(
            text="post with bad image", author=self.user, group=self.group
        )
        file = SimpleUploadedFile("filename.txt", b"hello world", "text/plain")
        response = self.auth_client.post(
            reverse(
                "post_edit",
                kwargs={"post_id": post.id, "username": self.user.username},
            ),
            data={"group": self.group.id, "text": "post with bad image", "image": file},
            follow=True,
        )
        self.assertEqual(response.status_code, 200)
        self.assertFormError(
            response,
            "form",
            "image",
            "Загрузите правильное изображение. Файл, который вы загрузили, поврежден или не является изображением.",
        )
Beispiel #45
0
class ProposalTest(TestCase):
    fixtures = ['user.json', 'socialapp.json']

    def setUp(self):
        self.client = Client()
        self.event = Event.objects.create(**EVENT_DATA)
        self.proposal_data = PROPOSAL_DATA.copy()
        self.proposal_data.update(event=self.event)
        self.proposal = Proposal.objects.create(**self.proposal_data)
        self.client.login(username='******', password='******')

    def test_empty_list_proposal(self):
        self.proposal.delete()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'], [])

    def test_list_proposal(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])

    # Starts Admin Overview
    def test_list_proposal_as_admin_user(self):
        self.client.login(username='******', password='******')
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])

    def test_list_proposal_without_public_voting_as_admin_user(self):
        self.client.login(username='******', password='******')
        self.event.allow_public_voting = False
        self.event.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])

    def test_list_proposal_without_published_and_as_admin_user(self):
        self.client.login(username='******', password='******')
        self.event.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])

    def test_list_proposal_without_public_voting_and_without_published_and_as_admin_user(self):
        self.client.login(username='******', password='******')
        self.event.allow_public_voting = False
        self.event.save()
        self.proposal.is_published = False
        self.proposal.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])
    # Ends Admin Overview

    # Starts Author Overview
    def test_list_proposal_as_author(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.event.author = User.objects.get(username='******')
        self.event.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])

    def test_list_proposal_without_public_voting_as_author(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.event.author = User.objects.get(username='******')
        self.event.allow_public_voting = False
        self.event.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])

    def test_list_proposal_without_published_and_as_author(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.event.author = User.objects.get(username='******')
        self.event.save()
        self.proposal.is_published = False
        self.proposal.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])

    def test_list_proposal_without_public_voting_and_without_published_and_as_author(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.event.author = User.objects.get(username='******')
        self.event.allow_public_voting = False
        self.event.save()
        self.proposal.is_published = False
        self.proposal.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])
    # Ends Author Overview

    # Starts User Overview
    def test_list_proposal_as_user(self):
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ['<Proposal: Python For Zombies>'])

    def test_list_proposal_without_public_voting_as_user(self):
        self.event.allow_public_voting = False
        self.event.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'], [])

    def test_list_proposal_without_published_and_as_user(self):
        self.proposal.is_published = False
        self.proposal.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ['<Proposal: Python For Zombies>'])

    def test_list_proposal_without_public_voting_and_without_published_and_as_user(self):
        self.event.allow_public_voting = False
        self.event.save()
        self.proposal.is_published = False
        self.proposal.save()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'], [])
    # Ends User Overview

    def test_list_proposal_without_logged_user(self):
        self.client.logout()
        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ['<Proposal: Python For Zombies>'])

    def test_list_proposal_without_public_voting(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.event.allow_public_voting = False
        self.event.save()

        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'], [])

    def test_list_proposal_without_public_voting_and_without_logged_user(self):
        self.client.logout()
        self.event.allow_public_voting = False
        self.event.save()

        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'], [])

    def test_list_proposal_with_public_voting(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.event.allow_public_voting = True
        self.event.save()
        self.proposal.is_published = True
        self.proposal.save()

        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>"])

    def test_list_proposal_ordering_when_user_is_logged(self):
        another_proposal_data = ANOTHER_PROPOSAL_DATA.copy()
        another_proposal_data.update(event=self.event)
        another_proposal = Proposal.objects.create(**another_proposal_data)

        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: A Python 3 Metaprogramming Tutorial>",
                                  "<Proposal: Python For Zombies>"])

        rate_proposal_data = {
            'event_slug': another_proposal.event.slug,
            'slug': another_proposal.slug,
            'rate': 'laughing'
        }
        self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        response = self.client.get(
            reverse('view_event', kwargs={'slug': self.event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_proposals'],
                                 ["<Proposal: Python For Zombies>",
                                  "<Proposal: A Python 3 Metaprogramming Tutorial>"])

    def test_update_proposal(self):
        new_proposal_data = self.proposal_data.copy()
        new_proposal_data['description'] = 'A really really good proposal.'

        self.assertEquals(self.proposal_data['description'],
                          self.proposal.description)

        response = self.client.get(
            reverse('update_proposal',
                    kwargs={'event_slug': self.event.slug,
                            'slug': self.proposal.slug}))
        self.assertEqual(response.context['event'], self.event)

        response = self.client.post(
            reverse('update_proposal',
                    kwargs={'event_slug': self.event.slug,
                            'slug': self.proposal.slug}),
            new_proposal_data, follow=True)

        self.assertEquals(200, response.status_code)
        self.proposal = response.context['event'].proposals.first()
        self.assertEquals('Python For Zombies', self.proposal.title)
        self.assertEquals('A really really good proposal.',
                          self.proposal.description)

    def test_anonymous_user_update_proposal(self):
        self.client.logout()
        new_proposal_data = self.proposal_data.copy()
        new_proposal_data['description'] = 'A really really good proposal.'
        proposal_update_url = reverse(
            'update_proposal',
            kwargs={'event_slug': self.event.slug,
                    'slug': self.proposal.slug})
        response = self.client.post(
            proposal_update_url,
            new_proposal_data, follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertEquals(proposal_update_url,
                          response.context_data.get('redirect_field_value'))
        self.assertEquals('Brain...', self.proposal.description)

    def test_delete_proposal(self):
        new_proposal_data = self.proposal_data.copy()
        new_proposal_data['author_id'] = User.objects.get(username='******').id
        new_proposal_data['description'] = 'A good candidate to be deleted.'
        proposal = Proposal.objects.create(**new_proposal_data)

        self.assertEqual(
            Proposal.objects.filter(slug=proposal.slug).count(), 1)

        response = self.client.post(
            reverse('delete_proposal',
                    kwargs={'event_slug': proposal.event.slug,
                            'slug': proposal.slug}), follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, 'Proposal deleted.')
        self.assertEqual(
            Proposal.objects.filter(slug=proposal.slug).count(), 0)

    def test_not_allowed_to_delete_proposal(self):
        response = self.client.post(
            reverse('delete_proposal',
                    kwargs={'event_slug': self.proposal.event.slug,
                            'slug': self.proposal.slug}), follow=True)
        self.assertEqual(200, response.status_code)
        self.assertContains(response, 'You are not allowed to see this page.')

    def test_rate_proposal(self):
        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'laughing'
        }
        response = self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(1, Vote.objects.count())
        self.assertEquals(1, self.proposal.votes.count())
        self.assertEquals(3, self.proposal.get_rate)

    def test_rate_proposal_by_get(self):
        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'laughing'
        }
        response = self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(1, Vote.objects.count())
        self.assertEquals(1, self.proposal.votes.count())
        self.assertEquals(3, self.proposal.get_rate)

    def test_rate_proposal_in_a_disallowed_event(self):
        self.client.logout()
        self.client.login(username='******', password='******')

        self.event.allow_public_voting = False
        self.event.save()

        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }
        response = self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(401, response.status_code)
        self.assertEquals(0, self.proposal.get_rate)
        self.assertEquals(0, self.proposal.votes.count())
        self.assertEquals(0, Vote.objects.count())

    def test_rate_proposal_in_a_disallowed_event_by_get(self):
        self.client.logout()
        self.client.login(username='******', password='******')

        self.event.allow_public_voting = False
        self.event.save()

        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }
        response = self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(0, self.proposal.get_rate)
        self.assertEquals(0, self.proposal.votes.count())
        self.assertEquals(0, Vote.objects.count())

    def test_rate_proposal_overrated_value(self):
        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'whatever'
        }
        response = self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(400, response.status_code)
        self.assertIn('message', json.loads(response.content))
        self.assertEquals(0, self.proposal.get_rate)
        self.assertEquals(0, self.proposal.votes.count())
        self.assertEquals(0, Vote.objects.count())

    def test_rate_proposal_overrated_value_by_get(self):
        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'whatever'
        }
        response = self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(0, self.proposal.get_rate)
        self.assertEquals(0, self.proposal.votes.count())
        self.assertEquals(0, Vote.objects.count())

    def test_rate_proposal_multiple_times(self):
        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'laughing'
        }
        self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        rate_proposal_data.update({'rate': 'happy'})
        response = self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )
        self.assertEquals(401, response.status_code)
        self.assertEquals(1, Vote.objects.count())
        self.assertEquals(1, self.proposal.votes.count())
        self.assertEquals(3, self.proposal.get_rate)

    def test_rate_proposal_multiple_times_by_get(self):
        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'laughing'
        }
        self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        rate_proposal_data.update({'rate': 'happy'})
        response = self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertEquals(1, Vote.objects.count())
        self.assertEquals(1, self.proposal.votes.count())
        self.assertEquals(3, self.proposal.get_rate)

    def test_rate_proposal_with_the_same_author(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.author = User.objects.get(username='******')
        self.proposal.save()

        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }
        response = self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(401, response.status_code)
        self.assertEquals(0, self.proposal.get_rate)
        self.assertEquals(0, self.proposal.votes.count())
        self.assertEquals(0, Vote.objects.count())

    def test_rate_proposal_with_the_same_author_by_get(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.author = User.objects.get(username='******')
        self.proposal.save()

        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }
        response = self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(0, self.proposal.get_rate)
        self.assertEquals(0, self.proposal.votes.count())
        self.assertEquals(0, Vote.objects.count())

    def test_anonymous_user_rate_proposal(self):
        self.client.logout()
        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }

        response = self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )
        self.assertEquals(401, response.status_code)
        self.assertIn('message', json.loads(response.content))
        self.assertEquals(0, self.proposal.get_rate)
        self.assertEquals(0, self.proposal.votes.count())
        self.assertEquals(0, Vote.objects.count())

    def test_anonymous_user_rate_proposal_by_get(self):
        self.client.logout()
        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }

        response = self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertEquals(0, self.proposal.get_rate)
        self.assertEquals(0, self.proposal.votes.count())
        self.assertEquals(0, Vote.objects.count())

    def test_rate_proposal_with_the_admin_user(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.author = User.objects.get(username='******')
        self.proposal.save()

        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }
        response = self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(1, self.proposal.get_rate)
        self.assertEquals(1, self.proposal.votes.count())
        self.assertEquals(1, Vote.objects.count())

    def test_rate_proposal_with_the_admin_user_by_get(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.author = User.objects.get(username='******')
        self.proposal.save()

        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }
        response = self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(1, self.proposal.get_rate)
        self.assertEquals(1, self.proposal.votes.count())
        self.assertEquals(1, Vote.objects.count())

    def test_rate_proposal_with_the_jury_user(self):
        self.event.jury.users.add(User.objects.get(username='******'))
        self.client.logout()
        self.client.login(username='******', password='******')

        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }
        response = self.client.post(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(1, self.proposal.get_rate)
        self.assertEquals(1, self.proposal.votes.count())
        self.assertEquals(1, Vote.objects.count())

    def test_rate_proposal_with_the_jury_user_by_get(self):
        self.event.jury.users.add(User.objects.get(username='******'))
        self.client.logout()
        self.client.login(username='******', password='******')

        rate_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
            'rate': 'sad'
        }
        response = self.client.get(
            reverse('rate_proposal', kwargs=rate_proposal_data),
            follow=True
        )

        self.assertEquals(200, response.status_code)
        self.assertEquals(1, self.proposal.get_rate)
        self.assertEquals(1, self.proposal.votes.count())
        self.assertEquals(1, Vote.objects.count())

    def test_approve_proposal_with_the_anonymous_user(self):
        self.client.logout()
        approve_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
        }

        response = self.client.post(
            reverse('approve_proposal', kwargs=approve_proposal_data),
            follow=True
        )
        self.proposal = Proposal.objects.first()
        self.assertEquals(401, response.status_code)
        self.assertIn('message', json.loads(response.content))
        self.assertEquals(False, self.proposal.is_approved)

    def test_approve_proposal_with_the_admin_user(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.author = User.objects.get(username='******')
        self.proposal.save()

        approve_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
        }
        response = self.client.post(
            reverse('approve_proposal', kwargs=approve_proposal_data),
            follow=True
        )

        self.proposal = Proposal.objects.first()
        self.assertEquals(200, response.status_code)
        self.assertIn('message', json.loads(response.content))
        self.assertEquals(True, self.proposal.is_approved)

    def test_approve_proposal_with_the_admin_user_by_get(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.author = User.objects.get(username='******')
        self.proposal.save()

        approve_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug
        }
        response = self.client.get(
            reverse('approve_proposal', kwargs=approve_proposal_data),
            follow=True
        )

        self.proposal = Proposal.objects.first()
        self.assertEquals(200, response.status_code)
        self.assertEquals(True, self.proposal.is_approved)

    def test_approve_proposal_with_the_jury_user(self):
        self.event.jury.users.add(User.objects.get(username='******'))
        self.client.logout()
        self.client.login(username='******', password='******')

        approve_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug
        }
        response = self.client.post(
            reverse('approve_proposal', kwargs=approve_proposal_data),
            follow=True
        )

        self.proposal = Proposal.objects.first()
        self.assertEquals(200, response.status_code)
        self.assertIn('message', json.loads(response.content))
        self.assertEquals(True, self.proposal.is_approved)

    def test_approve_proposal_with_the_jury_user_by_get(self):
        self.event.jury.users.add(User.objects.get(username='******'))
        self.client.logout()
        self.client.login(username='******', password='******')

        approve_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug
        }
        response = self.client.get(
            reverse('approve_proposal', kwargs=approve_proposal_data),
            follow=True
        )

        self.proposal = Proposal.objects.first()
        self.assertEquals(200, response.status_code)
        self.assertEquals(True, self.proposal.is_approved)

    def test_disapprove_proposal_with_the_anonymous_user(self):
        self.proposal.is_approved = True
        self.proposal.save()

        self.client.logout()
        disapprove_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
        }

        response = self.client.post(
            reverse('disapprove_proposal', kwargs=disapprove_proposal_data),
            follow=True
        )
        self.proposal = Proposal.objects.first()
        self.assertEquals(401, response.status_code)
        self.assertIn('message', json.loads(response.content))
        self.assertEquals(True, self.proposal.is_approved)

    def test_disapprove_proposal_with_the_admin_user(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.author = User.objects.get(username='******')
        self.proposal.is_approved = True
        self.proposal.save()

        disapprove_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug,
        }
        response = self.client.post(
            reverse('disapprove_proposal', kwargs=disapprove_proposal_data),
            follow=True
        )

        self.proposal = Proposal.objects.first()
        self.assertEquals(200, response.status_code)
        self.assertIn('message', json.loads(response.content))
        self.assertEquals(False, self.proposal.is_approved)

    def test_disapprove_proposal_with_the_admin_user_by_get(self):
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.author = User.objects.get(username='******')
        self.proposal.is_approved = True
        self.proposal.save()

        disapprove_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug
        }
        response = self.client.get(
            reverse('disapprove_proposal', kwargs=disapprove_proposal_data),
            follow=True
        )

        self.proposal = Proposal.objects.first()
        self.assertEquals(200, response.status_code)
        self.assertEquals(False, self.proposal.is_approved)

    def test_disapprove_proposal_with_the_jury_user(self):
        self.event.jury.users.add(User.objects.get(username='******'))
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.is_approved = True
        self.proposal.save()

        disapprove_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug
        }
        response = self.client.post(
            reverse('disapprove_proposal', kwargs=disapprove_proposal_data),
            follow=True
        )

        self.proposal = Proposal.objects.first()
        self.assertEquals(200, response.status_code)
        self.assertIn('message', json.loads(response.content))
        self.assertEquals(False, self.proposal.is_approved)

    def test_disapprove_proposal_with_the_jury_user_by_get(self):
        self.event.jury.users.add(User.objects.get(username='******'))
        self.client.logout()
        self.client.login(username='******', password='******')
        self.proposal.is_approved = True
        self.proposal.save()

        disapprove_proposal_data = {
            'event_slug': self.proposal.event.slug,
            'slug': self.proposal.slug
        }
        response = self.client.get(
            reverse('disapprove_proposal', kwargs=disapprove_proposal_data),
            follow=True
        )

        self.proposal = Proposal.objects.first()
        self.assertEquals(200, response.status_code)
        self.assertEquals(False, self.proposal.is_approved)

    def test_send_welcome_mail(self):
        User = namedtuple('User', 'email')
        fake_user = User('*****@*****.**')
        send_welcome_mail(None, fake_user)

        self.assertEqual(1, len(mail.outbox))
        email = mail.outbox[0]

        self.assertTrue('Welcome', email.subject)
        self.assertIn(fake_user.email, email.recipients())
        self.assertIn(settings.NO_REPLY_EMAIL, email.from_email)

    def test_send_proposal_deleted_mail(self):
        user = User.objects.get(username='******')
        self.proposal.event.jury.users.add(user)
        send_proposal_deleted_mail(Proposal, self.proposal)
        self.assertEqual(1, len(mail.outbox))
        email = mail.outbox[0]
        self.assertEqual('Proposal from RuPy just got deleted', email.subject)
        self.assertIn('*****@*****.**', email.recipients())
        self.assertIn('*****@*****.**', email.recipients())
        self.assertIn('Python For Zombies', email.body)
        self.assertIn(settings.NO_REPLY_EMAIL, email.from_email)

    def test_my_proposals_menu_for_authenticated_users(self):
        response = self.client.get(reverse('list_events'))
        self.assertContains(response, 'My Proposals')

    def test_my_proposals_menu_for_non_authenticated_users(self):
        self.client.logout()
        response = self.client.get(reverse('list_events'))
        self.assertNotContains(response, 'My Proposals')

    def test_users_should_see_their_proposals(self):
        user = User.objects.get(username='******')
        self.proposal.author = user
        self.proposal.save()
        response = self.client.get(reverse('my_proposals'))
        self.assertQuerysetEqual(response.context['object_list'],
                                 ['<Proposal: Python For Zombies>'])
Beispiel #46
0
class TestViews(EleprofileTestBase):
    def setUp(self):
        self.client = Client()

    def _test_ACL(self, url, response_url=''):

        # As Anonymoususer: aspected 302 redirect con login
        response = self.client.get(url)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, response_url)

        # As Viewer1
        self.assertTrue(
            self.client.login(username=self.test_viewer1.username,
                              password=self.test_viewer1.username))
        response = self.client.get(url)
        self.assertEqual(response.status_code, 403)
        self.client.logout()

    def test_eleproproject_list(self):
        """ Testing ProjectView """

        url = reverse('eleprofile-project-list')

        self._test_ACL(url,
                       response_url='/en/login/?next=/en/eleprofile/projects/')

        # as Admin01
        self.assertTrue(
            self.client.login(username=self.test_admin1.username,
                              password=self.test_admin1.username))
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

        self.client.logout()

        # FIXME: add possible html tests parsing.

    def test_eleproproject_create(self):
        """ Testing ProjectCreateView """

        url = reverse('eleprofile-project-add')

        self._test_ACL(
            url, response_url='/en/login/?next=/en/eleprofile/projects/add/')

        # as Admin01
        self.assertTrue(
            self.client.login(username=self.test_admin1.username,
                              password=self.test_admin1.username))

        data = {
            'project': self.project.instance.pk,
            'note': "<strong>test</strong> note"
        }
        response = self.client.post(url, data)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, '/en/eleprofile/projects/')

        eleproprjs = EleProProject.objects.all()
        self.assertEqual(len(eleproprjs), 1)
        self.assertEqual(eleproprjs[0].project_id, self.project.instance.pk)
        self.assertEqual(eleproprjs[0].note, "<strong>test</strong> note")

        self.client.logout()

    def test_eleproproject_update(self):
        """ Testing ProjectUpdateView """

        # Create a eleproproject to update
        epp = EleProProject(project=self.project.instance, note="test note")
        epp.save()

        url = reverse('eleprofile-project-update', args=[epp.pk])

        self._test_ACL(
            url,
            response_url=
            f'/en/login/?next=/en/eleprofile/projects/update/{epp.pk}/')

        # as Admin01
        self.assertTrue(
            self.client.login(username=self.test_admin1.username,
                              password=self.test_admin1.username))

        data = {'project': epp.project_id, 'note': "test note updated"}
        response = self.client.post(url, data)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, '/en/eleprofile/projects/')

        eleproprjs = EleProProject.objects.all()
        self.assertEqual(len(eleproprjs), 1)
        self.assertEqual(eleproprjs[0].project_id, self.project.instance.pk)
        self.assertEqual(eleproprjs[0].note, "test note updated")

        self.client.logout()

    def test_eleproproject_delete(self):
        """ Testing ProjectDeleteView """

        # Create a eleproproject to update
        epp = EleProProject(project=self.project.instance,
                            note="test note to delete")
        epp.save()

        url = reverse('eleprofile-project-delete', args=[epp.pk])

        self._test_ACL(
            url,
            response_url=
            f'/en/login/?next=/en/eleprofile/projects/delete/{epp.pk}/')

        # as Admin01
        self.assertTrue(
            self.client.login(username=self.test_admin1.username,
                              password=self.test_admin1.username))

        response = self.client.post(url)
        self.assertEqual(response.status_code, 200)

        eleproprjs = EleProProject.objects.all()
        self.assertEqual(len(eleproprjs), 0)

        self.client.logout()

    def test_dtmlayer_list(self):
        """ Testing DTMListView """

        epp = EleProProject(project=self.project.instance,
                            note="test for dtm layer and path layers")
        epp.save()

        url = reverse('eleprofile-dtmlayer-list', args=[epp.pk])

        self._test_ACL(
            url,
            response_url=
            f'/en/login/?next=/en/eleprofile/projects/dtm/{epp.pk}/')

        # as Admin01
        self.assertTrue(
            self.client.login(username=self.test_admin1.username,
                              password=self.test_admin1.username))
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

        # parsing response content
        soup = BeautifulSoup(response.content, 'lxml')

        # check for empty table
        # only table th
        self.assertEqual(len(soup.find_all('tr')), 1)
        self.assertEqual(soup.find_all('tr')[0].th.text, 'Actions')

        self.client.logout()

    def test_dtmlayer_create(self):
        """ Testing DTMCreateView """

        epp = EleProProject(project=self.project.instance,
                            note="test for dtm layer and path layers")
        epp.save()

        url = reverse('eleprofile-dtmlayer-add', args=[epp.pk])

        self._test_ACL(
            url,
            response_url=
            f'/en/login/?next=/en/eleprofile/projects/dtm/{epp.pk}/add/')

        # as Admin01
        self.assertTrue(
            self.client.login(username=self.test_admin1.username,
                              password=self.test_admin1.username))

        dtm_layer = Layer.objects.get(name='dtm_3857')
        line_layer = Layer.objects.get(name='paths')
        data = {
            'elepro_project': epp.pk,
            'dtm_layer': dtm_layer.pk,
            'dtm_delta': 10,
            'layers': [line_layer.pk],
            'note': "<strong>test</strong> note for dtm layers"
        }
        response = self.client.post(url, data)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url,
                         f'/en/eleprofile/projects/dtm/{epp.pk}/')

        eleprodtm = EleProDTM.objects.all()
        self.assertEqual(len(eleprodtm), 1)
        self.assertEqual(eleprodtm[0].dtm_layer, dtm_layer)
        self.assertEqual(eleprodtm[0].note,
                         "<strong>test</strong> note for dtm layers")

        # check list
        url = reverse('eleprofile-dtmlayer-list', args=[epp.pk])
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

        # parsing response content
        soup = BeautifulSoup(response.content, 'lxml')

        # check for empty table
        # only table th
        self.assertEqual(len(soup.find_all('tr')), 2)

        self.client.logout()

    def test_dtmlayer_update(self):
        """ Testing DTMUpdateView """

        # Create a eleproproject
        epp = EleProProject(project=self.project.instance, note="test note")
        epp.save()

        # Create a DTM layer
        dtm_layer = Layer.objects.get(name='dtm_3857')
        line_layer = Layer.objects.get(name='paths')

        epdtm = EleProDTM(elepro_project=epp,
                          dtm_layer=dtm_layer,
                          note='note dtm layer for update')
        epdtm.save()
        epdtm.layers.add(line_layer)

        url = reverse('eleprofile-dtmlayer-update', args=[epp.pk, epdtm.pk])

        self._test_ACL(
            url,
            response_url=
            f'/en/login/?next=/en/eleprofile/projects/dtm/{epp.pk}/update/{epdtm.pk}/'
        )

        # as Admin01
        self.assertTrue(
            self.client.login(username=self.test_admin1.username,
                              password=self.test_admin1.username))

        data = {
            'elepro_project': epp.pk,
            'dtm_layer': dtm_layer.pk,
            'dtm_delta': 12,
            'layers': [line_layer.pk],
            'note': "test note updated"
        }
        response = self.client.post(url, data)
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url,
                         f'/en/eleprofile/projects/dtm/{epp.pk}/')

        eleprodtm = EleProDTM.objects.all()
        self.assertEqual(len(eleprodtm), 1)
        self.assertEqual(eleprodtm[0].elepro_project, epp)
        self.assertEqual(eleprodtm[0].dtm_delta, 12)
        self.assertEqual(eleprodtm[0].note, "test note updated")

        self.client.logout()

    def test_dtmlayer_delete(self):
        """ Testing DTMDeleteView """

        # Create a eleproproject
        epp = EleProProject(project=self.project.instance, note="test note")
        epp.save()

        # Create a DTM layer
        dtm_layer = Layer.objects.get(name='dtm_3857')
        line_layer = Layer.objects.get(name='paths')

        epdtm = EleProDTM(elepro_project=epp,
                          dtm_layer=dtm_layer,
                          note='note dtm layer for update')
        epdtm.save()
        epdtm.layers.add(line_layer)

        url = reverse('eleprofile-dtmlayer-delete', args=[epp.pk, epdtm.pk])

        self._test_ACL(
            url,
            response_url=
            f'/en/login/?next=/en/eleprofile/projects/dtm/{epp.pk}/delete/{epdtm.pk}/'
        )

        # as Admin01
        self.assertTrue(
            self.client.login(username=self.test_admin1.username,
                              password=self.test_admin1.username))

        eleprodtm = EleProDTM.objects.all()
        self.assertEqual(len(eleprodtm), 1)

        response = self.client.post(url)
        self.assertEqual(response.status_code, 200)

        eleprodtm = EleProDTM.objects.all()
        self.assertEqual(len(eleprodtm), 0)

        self.client.logout()
Beispiel #47
0
 def test_user_logout(self):
     client = Client()
     client.logout()
Beispiel #48
0
class change_password_view_Test(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create(email="*****@*****.**")
        self.user.set_password("abc123")
        self.user.save()

    def test_change_pwd_get(self):
        self.client.login(email="*****@*****.**", password="******")
        url = "/admin/change_password/"
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_change_pwd_form_valid(self):
        user_login = self.client.login(email="*****@*****.**",
                                       password="******")
        url = "/admin/change_password/"
        data = {
            'old_password': "******",
            'new_password': "******",
            're_password': "******"
        }
        response = self.client.post(url, data)
        self.assertEqual(response.status_code, 200)
        self.client.logout()
        user_login = self.client.login(email="*****@*****.**",
                                       password="******")
        self.assertTrue(user_login)

    def test_change_pwd_form_invalid(self):
        self.client.login(email="*****@*****.**", password="******")
        url = "/admin/change_password/"
        data = {
            'old_password': "******",
            'new_password': "",
            're_password': ""
        }
        response = self.client.post(url, data)
        self.assertEqual(response.status_code, 200)

    def test_change_re_pwd(self):
        self.client.login(email="*****@*****.**", password="******")
        url = "/admin/change_password/"
        data = {
            'old_password': "******",
            'new_password': "******",
            're_password': "******"
        }
        response = self.client.post(url, data)
        self.assertEqual(response.status_code, 200)

    def test_change_old_pwd(self):
        self.client.login(email="*****@*****.**", password="******")
        url = "/admin/change_password/"
        data = {
            'old_password': "******",
            'new_password': "******",
            're_password': "******"
        }
        response = self.client.post(url, data)
        self.assertEqual(response.status_code, 200)
Beispiel #49
0
class ViewsTest(TestCase):
    """
    Class with testclient to test views. Some functions to setup data in the database.
    """
    def setUp(self):
        """
        Setup test data, like users and groups.
        """
        # whether to produce output, please override this on app level if debug is required.
        self.debug = False

        # to test that each page is at least tested once, check if all urls of the app are tested.
        urlpatterns = import_module(self.app + '.urls',
                                    'urlpatterns').urlpatterns
        self.allurls = [x.name for x in urlpatterns]

        # the client used for testing
        if TEST_HTML_VALID:
            self.client = ValidatingClient()
        else:
            self.client = Client()
        # info string to show debug info in case of test assertion failure
        self.info = {}

        # The timeslot used for testing proposal of current timeslot
        self.ts = TimeSlot(Begin=datetime.now(),
                           End=datetime.now() + timedelta(days=3),
                           Name='thisyear')
        self.ts.save()

        # The timephase used for testing. The Description is changed every test.
        self.tp = TimePhase(Begin=datetime.now(),
                            End=datetime.now() + timedelta(days=3),
                            TimeSlot=self.ts,
                            Description=1)
        self.tp.save()

        # The timeslot used for testing proposal of next timeslot
        self.nts = TimeSlot(Begin=datetime.now() + timedelta(days=5),
                            End=datetime.now() + timedelta(days=8),
                            Name='nextyear')
        self.nts.save()

        # The timeslot used for testing proposal of previous timeslot
        self.pts = TimeSlot(Begin=datetime.now() - timedelta(days=5),
                            End=datetime.now() - timedelta(days=3),
                            Name='prevyear')
        self.pts.save()

        # Create capacity groups models
        groups = (("EES", "Electrical Energy Systems"),
                  ("ECO", "Electro-Optical Communications"),
                  ("EPE", "Electromechanics and Power Electronics"),
                  ("ES", "Electronic Systems"), ("IC", "Integrated Circuits"),
                  ("CS", "Control Systems"), ("SPS",
                                              "Signal Processing Systems"),
                  ("PHI", "Photonic Integration"), ("EM", "Electromagnetics"))

        for group in groups:
            self.c, created = CapacityGroup.objects.get_or_create(
                ShortName=group[0], FullName=group[1])
            assert created

        # Create groups and users
        self.create_groups()
        self.create_users()

        # Track for automotive, with trackhead t-h. Automotive track must exist because it is special. (distributions)
        th = User.objects.get(username='******')
        self.track = Track(Name='Automotive', ShortName='AU', Head=th)
        self.track.save()

        grt = User.objects.get(username='******')
        grr = User.objects.get(username='******')
        # only read/write administration is tested. Not readonly.
        g = GroupAdministratorThrough(User=grt,
                                      Super=True,
                                      Group=CapacityGroup.objects.all()[0])
        g.save()
        g2 = GroupAdministratorThrough(User=grr,
                                       Super=True,
                                       Group=CapacityGroup.objects.all()[1])
        g2.save()

        ## setup matrix with all possible rights
        # expected results:
        # r=random, t=this(for this proposal)
        # s=student, p=private-student, r=responsible, a=assistant, u=assistant_not_verified t=trackhead
        # ta = assessor of presentation, 4=groupadministration, 5=studyadvisor, 6=profskill
        # matrix with different types of permissions, set for each user of the array self.usernames
        # permissions by user. The order is the order of self.usernames. User 'god' is disabled (not tested).
        #  usernames:    r-1  t-1  r-h  t-h  r-2  t-2  t-u  r-3  r-s  t-p  r-4  t-4  r-5  r-6  ra-1  ta-1  sup, ano
        self.p_forbidden = [
            403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
            403, 403, 403, 403, 302
        ]  # no one
        self.p_superuser = [
            403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
            403, 403, 403, 200, 302
        ]  # no one
        self.p_all = [
            200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
            200, 200, 200, 200, 302
        ]  # everyone
        self.p_anonymous = [
            200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
            200, 200, 200, 200, 200
        ]  # everyone
        self.p_redirect = [
            302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302, 302,
            302, 302, 302, 302, 302
        ]  # everyone

        self.p_staff = [
            200, 200, 200, 200, 200, 200, 200, 200, 403, 403, 200, 200, 200,
            200, 200, 200, 200, 302
        ]  # all staff, general
        self.p_staff_veri = [
            200, 200, 200, 200, 200, 200, 403, 200, 403, 403, 200, 200, 200,
            200, 200, 200, 200, 302
        ]  # all staff, without unverified
        self.p_staff122u35 = [
            200, 200, 200, 200, 200, 200, 200, 200, 403, 403, 403, 403, 200,
            403, 200, 200, 200, 302
        ]  # all staff, for chooseedit list
        self.p_staff_prop = [
            200, 200, 200, 200, 200, 200, 200, 200, 403, 403, 200, 200, 403,
            403, 200, 200, 200, 302
        ]  # all staff, to create proposals
        self.p_staff_prop_no4 = [
            200, 200, 200, 200, 200, 200, 200, 200, 403, 403, 403, 403, 403,
            403, 200, 200, 200, 302
        ]  # all staff to create but no type4
        self.p_staff_prop_nou = [
            200, 200, 200, 200, 200, 200, 403, 200, 403, 403, 200, 200, 403,
            403, 200, 200, 200, 302
        ]  # all staff, to create proposals, no unverified
        self.p_staff_stud = [
            200, 200, 200, 200, 200, 200, 403, 200, 403, 403, 403, 403, 403,
            200, 200, 200, 200, 302
        ]  # all staff that can see students (1,2,3,6)

        self.p_all_this = [
            403, 200, 403, 200, 403, 200, 200, 200, 403, 403, 403, 200, 403,
            403, 403, 403, 200, 302
        ]  # staff of this proposal
        self.p_all_this_pres = [
            403, 200, 403, 200, 403, 200, 200, 200, 403, 403, 403, 200, 403,
            403, 403, 200, 200, 302
        ]  # staff of this proposal including ta-1
        self.p_all_this_dist = [
            403, 200, 403, 200, 403, 200, 403, 200, 200, 403, 403, 403, 403,
            200, 403, 403, 200, 302
        ]  # staff of this proposal, as distributed to r-s (not t-p!). Also type6. For prv (no assessors)
        self.p_no_assistant = [
            403, 200, 403, 200, 403, 403, 403, 200, 403, 403, 403, 200, 403,
            403, 403, 403, 200, 302
        ]  # staff of this proposal except assistants. For up/downgrading and edit proposal.
        self.p_staff_prv_results = [
            403, 200, 403, 200, 403, 200, 403, 200, 403, 403, 403, 403, 403,
            403, 403, 403, 200, 302
        ]  # staff of this proposal except assistants including assessors. For results staff grading form, without assessor.
        self.p_staff_results = [
            403, 200, 403, 200, 403, 403, 403, 200, 403, 403, 403, 403, 403,
            403, 403, 200, 200, 302
        ]  # staff of this proposal except assistants including assessors. For results staff grading form.
        self.p_all_this_view = [
            403, 200, 403, 200, 403, 200, 200, 200, 403, 403, 403, 200, 403,
            403, 403, 403, 200, 302
        ]  # staff of this proposal including view only users (type4)

        self.p_private = [
            403, 200, 403, 200, 403, 200, 200, 200, 403, 200, 403, 200, 403,
            403, 403, 403, 200, 302
        ]  # private proposal view status 4
        self.p_private_pres = [
            403, 200, 403, 200, 403, 200, 200, 200, 403, 200, 403, 200, 403,
            403, 403, 200, 200, 302
        ]  # private proposal view status 4, in phase 7 or if presentation is public.
        self.p_trackhead = [
            403, 403, 403, 200, 403, 403, 403, 200, 403, 403, 403, 200, 403,
            403, 403, 403, 200, 302
        ]  # trackhead of proposal and support
        self.p_grade_final = [
            403, 403, 403, 200, 403, 403, 403, 403, 403, 403, 403, 403, 403,
            403, 403, 200, 200, 302
        ]  # Trackhead and assessor can finalize grades.
        self.p_grade_staff = [
            403, 200, 403, 200, 403, 403, 403, 200, 403, 403, 403, 403, 403,
            403, 403, 200, 200, 302
        ]  # staff of this proposal except assistants, for grading
        self.p_track = [
            403, 403, 200, 200, 403, 403, 403, 403, 403, 403, 403, 403, 403,
            403, 403, 403, 403, 302
        ]  # any trackhead
        self.p_pending = [
            200, 200, 200, 200, 200, 200, 200, 403, 403, 403, 200, 200, 403,
            403, 200, 200, 200, 302
        ]  # staff with pending proposals

        self.p_support = [
            403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 403, 403, 403,
            403, 403, 403, 200, 302
        ]  # type3 support
        self.p_support_prv = [
            403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 403, 403, 403,
            200, 403, 403, 200, 302
        ]  # 3+6

        self.p_cgadmin = [
            403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 200, 200, 403,
            403, 403, 403, 200, 302
        ]  # type4 (not superuser)
        # self.p_study        =   [403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 403, 200, 302]  # type5
        self.p_prv = [
            403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
            200, 403, 403, 200, 302
        ]  # 6

        self.p_student = [
            403, 403, 403, 403, 403, 403, 403, 403, 200, 200, 403, 403, 403,
            403, 403, 403, 403, 302
        ]  # any student
        self.p_studentnotpriv = [
            403, 403, 403, 403, 403, 403, 403, 403, 200, 403, 403, 403, 403,
            403, 403, 403, 403, 302
        ]  # student without private proposal

        self.p_download_share = [
            404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404,
            404, 404, 404, 404, 403
        ]  # used to test filesdownload (with sharelink proposals)
        self.p_404 = [
            404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 404,
            404, 404, 404, 404, 302
        ]  # used to test filesdownload

    def create_groups(self):
        """
        Create all groups for the system.

        :param self:
        :return:
        """
        # setup all groups
        self.group_names = [
            'type1staff',  # project responsible
            'type2staff',  # project assistant
            'type2staffunverified',  # unverified assistant
            'type3staff',  # support staff
            'type4staff',  # Capacity group administration
            'type5staff',  # Study advisor
            'type6staff',  # Prof skill administration
        ]
        for g in self.group_names:
            group, created = Group.objects.get_or_create(name=g)
            assert created
            # make group object accessable as a class variable. < self.type1staff > etc.
            setattr(self, g, group)

    def create_users(self):
        """
        Takes self.usernames and creates users based on this. The last character of the username determnines the group
        WARNING: This only generates users and assign groups.
        It does not assign roles (like groupadministration and trackhead models).
        """
        # create testusers using the naming-patern: [r t]-[s p 1 2 u 3 t ]
        # r=random (any person of the given type), t=this(for this project)
        # 1=type1, 2=type2, 3=type3, s=Student, u=Unverified-type2, h=track-Head, p=Private-student
        self.usernames = [
            'r-1',  # responsible staff
            't-1',  # responsible staff
            'r-h',  # responsible staff, trackhead
            't-h',  # responsible staff, trackhead
            'r-2',  # assistant
            't-2',  # assistant
            't-u',  # unverified assistant
            'r-3',  # support staff
            'r-s',  # student without private proposal
            't-p',  # student with private proposal
            'r-4',  # Capacity group administration of other group than tested proposal
            't-4',  # Capacity group administration of group of tested proposal
            'r-5',  # Study advisor
            'r-6',  # Prof skill administration
            'ra-1',  # type1 and assessor of other project
            'ta-1',  # type1 and assessor of project
            'sup',  # god user (superuser)
            'ano',  # anonymous user
        ]
        # Create the users and assign groups/roles.
        self.users = {}
        for n in self.usernames:
            if n != 'ano':
                u = User(username=n)
                u.email = n + '@' + settings.STAFF_EMAIL_DOMAINS[0]
                u.save()
                x = n.split('-')[-1]
                if x == '1':
                    u.groups.add(self.type1staff)
                elif x == 'h':  # trackhead
                    u.groups.add(self.type1staff)
                elif x == '2':
                    u.groups.add(self.type2staff)
                elif x == 'u':
                    u.groups.add(self.type2staffunverified)
                elif x == '3':
                    u.groups.add(self.type3staff)
                elif x == '4':
                    u.groups.add(self.type4staff)
                elif x == '5':
                    u.groups.add(self.type5staff)
                elif x == '6':
                    u.groups.add(self.type6staff)
                elif n == 'sup':
                    u.groups.add(self.type3staff)
                    u.is_superuser = True
                    u.is_staff = True
                else:  # student
                    u.email = n + '@' + settings.STUDENT_EMAIL_DOMAINS[0]
                u.save()
                self.users[n] = u
                m = UserMeta(
                    User=u,
                    EnrolledBEP=True,
                )
                m.save()
                m.TimeSlot.add(self.ts)
                m.save()
                ua = UserAcceptedTerms(User=u)
                ua.save()

    def links_in_view_test(self, sourceurl, skip=[]):
        """
        Find all links in a response and check if they return status 200.

        :param sourceurl: the page which is parsed to test the links on the page.
        :param skip: urls to not test
        :return:
        """
        for user in self.users.values():
            if (user.username == 't-u' or user.username == 'r-u') and \
                    self.tp.Description > 3:
                # ignore unverfied assistants in later timephases
                continue
            if (user.username == 't-p' or user.username == 't-s') and \
                    self.tp.Description < 3:
                # ignore students in first timephases
                continue
            self.client.force_login(user)
            response = self.client.get(sourceurl)
            urls = re.findall(
                '/(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+/',
                str(response.content))
            urls = [
                x for x in urls
                if (">" not in x and "<" not in x and "//" not in x
                    and "/static/" not in x and "/logout/" not in x
                    and "tracking/live/" not in x and "tracking/viewnumber/"
                    not in x and "js_error_hook" not in x and x not in skip)
            ]

            for link in urls:  # select the url in href for all a tags(links)
                if link in skip:
                    continue
                if self.debug:
                    print('url: {}'.format(link))
                self.info['user'] = user.username
                self.view_test_status(link, 200)
            self.client.logout()

    def loop_phase_code_user(self, phases, codes):
        """
        Loop over the given phases and test with all codes

        :param phases:
        :param codes: list of views and expected status codes
        :return:
        """
        assert isinstance(phases, list) or isinstance(phases, range)
        for phase in phases:
            if phase != get_timephase_number():
                if phase == -1:
                    self.tp.Begin = datetime.now() + timedelta(days=1)
                    self.tp.save()
                    self.info['phase'] = 'No Phase'
                else:
                    self.tp.Begin = datetime.now()
                    self.tp.Description = phase
                    self.tp.save()
                    self.info['phase'] = str(phase)
            if self.debug:
                print("Testing phase {}".format(phase))
            self.loop_code_user(codes)

    def loop_code_user(self, codes):
        """
        Test all views for all users

        :param codes: list of views and expected status codes
        :return:
        """
        for page, status in codes:
            if self.debug:
                self.info['reverse'] = str(page)
                self.info['statuscodes'] = status
            view = self.app + ":" + page[0]
            if any(isinstance(i, list) for i in status):
                # we're dealing with proposals status tests here
                ProjectViewsTestGeneral.loop_user_status(
                    self, view, status, page[1])
            else:
                # normal test without proposals
                self.loop_user(view, status, page[1])
            # remove the page from the list of urls of this app.
            if page[0] in self.allurls: self.allurls.remove(page[0])

    def loop_user(self, view, status, kw=None):
        """
        Loop over the provided pages with status code for each user and test these.

        :param view: name of the page, for reverse view
        :param status: array of http status that is expected for each user
        :param kw: keyword args for the given view.
        :return:
        """
        for i, username in enumerate(self.usernames):
            self.info['user'] = username
            self.info['kw'] = kw
            if self.debug:
                self.info['user-index'] = i
            # log the user in
            if username != 'ano':
                u = User.objects.get(username=username)
                if self.debug:
                    self.info['user-groups'] = u.groups.all()
                    self.info['user-issuper'] = u.is_superuser
                self.client.force_login(u)
            self.view_test_status(reverse(view, kwargs=kw), status[i])
            if username != 'ano':
                self.client.logout()

    def view_test_status(self, link, expected):
        """
        Test a given view

        :param self: the instance for the testcase class, containing self.client, the testclient instance.
        :param link: a link to a view to test
        :param expected: the expected response code
        :return:
        """
        try:
            response = self.client.get(link)
            response_code = response.status_code
            if response_code == 403 or expected == 403:
                try:
                    exception = list(response.context[0])[0]["exception"]
                except:
                    try:
                        exception = list(response.context[0])[0]["Message"]
                    except:
                        # exception = response.context  # this is a large amount of information
                        exception = 'Reason not found in context!'
                self.info['exception'] = exception
            else:
                if response_code == 404:
                    for d in response.context.dicts:
                        try:
                            self.info['exception'] = d['Message']
                            break
                        except:
                            continue
                else:
                    self.info['exception'] = "no 403"
        except Exception as e:
            response_code = 500
            print("Error: {}".format(e))
            self.info['exception'] = '500'
            traceback.print_exc(file=sys.stdout)

        self.assertEqual(
            response_code,
            expected,
            msg='Expected status code {} but got {} for {} info: {}.'.format(
                expected, response_code, link, self.info))
Beispiel #50
0
class EntryAdminViewTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.entry1 = Registration.objects.create(
            first_name="John",
            last_name="Doe",
            email="*****@*****.**",
            programme="computingscience",
            student_number="s1234567",
            starting_year=2014,
            address_street="Heyendaalseweg 135",
            address_street2="",
            address_postal_code="6525AJ",
            address_city="Nijmegen",
            address_country="NL",
            phone_number="06123456789",
            birthday=timezone.now().replace(year=1990, day=1),
            length=Entry.MEMBERSHIP_YEAR,
            membership_type=Membership.MEMBER,
            status=Entry.STATUS_CONFIRM,
        )
        cls.user = get_user_model().objects.create_user(username="******")
        cls.entry2 = Renewal.objects.create(
            length=Entry.MEMBERSHIP_YEAR,
            membership_type=Membership.MEMBER,
            status=Entry.STATUS_CONFIRM,
            member=cls.user,
        )

    def setUp(self):
        self.rf = RequestFactory()
        self.client = Client()
        self.client.force_login(self.user)
        self.view = views.EntryAdminView()

    def _give_user_permissions(self):
        content_type = ContentType.objects.get_for_model(Entry)
        permissions = Permission.objects.filter(
            content_type__app_label=content_type.app_label, )
        for p in permissions:
            self.user.user_permissions.add(p)
        self.user.is_staff = True
        self.user.save()

        self.client.logout()
        self.client.force_login(self.user)

    def test_permissions(self):
        url = "/registration/admin/process/{}/".format(self.entry1.pk)
        response = self.client.post(url)
        self.assertRedirects(response, f"/admin/login/?next={url}")

        self._give_user_permissions()

        url = "/registration/admin/process/{}/".format(self.entry1.pk)
        response = self.client.post(url)
        self.assertRedirects(
            response,
            f"/admin/registrations/registration/{self.entry1.pk}/change/")

    @mock.patch("registrations.services.check_unique_user")
    @mock.patch("registrations.services.accept_entries")
    @mock.patch("registrations.services.reject_entries")
    def test_post_accept(self, reject_entries, accept_entries,
                         check_unique_user):
        self.view.action = "accept"
        for reg_type, entry in {
                "registration": self.entry1,
                "renewal": self.entry2,
        }.items():
            entry_qs = Entry.objects.filter(pk=entry.pk)
            check_unique_user.reset_mock()
            check_unique_user.return_value = True
            reject_entries.reset_mock()
            reject_entries.return_value = 1
            accept_entries.reset_mock()
            accept_entries.return_value = 1
            with mock.patch(
                    "registrations.models.Entry.objects.filter") as qs_mock:
                qs_mock.return_value = entry_qs
                qs_mock.get = Mock(return_value=entry_qs.get())

                request = self.rf.post(
                    f"/registration/admin/process/{entry.pk}/", {
                        "action": "accept",
                    })
                request.user = _get_mock_user()
                request.member = request.user
                request._messages = Mock()
                response = self.view.post(request, pk=entry.pk)

                self.assertEqual(response.status_code, 302)
                self.assertEqual(
                    response.url,
                    f"/admin/registrations/{reg_type}/{entry.pk}/change/",
                )

                accept_entries.assert_called_once_with(1, entry_qs)
                self.assertFalse(reject_entries.called)

                request._messages.add.assert_called_once_with(
                    messages.SUCCESS,
                    _("Successfully accepted %s.") %
                    model_ngettext(entry_qs.all()[0], 1),
                    "",
                )

                accept_entries.return_value = 0
                self.view.post(request, pk=entry.pk)

                request._messages.add.assert_any_call(
                    messages.ERROR,
                    _("Could not accept %s.") %
                    model_ngettext(entry_qs.all()[0], 1),
                    "",
                )

                accept_entries.return_value = 1
                check_unique_user.return_value = False
                self.view.post(request, pk=entry.pk)

                request._messages.add.assert_any_call(
                    messages.ERROR,
                    _("Could not accept %s. Username is not unique.") %
                    model_ngettext(entry_qs.all()[0], 1),
                    "",
                )

    @mock.patch("registrations.services.accept_entries")
    @mock.patch("registrations.services.reject_entries")
    def test_post_reject(self, reject_entries, accept_entries):
        self.view.action = "reject"
        for reg_type, entry in {
                "registration": self.entry1,
                "renewal": self.entry2,
        }.items():
            accept_entries.reset_mock()
            accept_entries.return_value = 1
            reject_entries.reset_mock()
            reject_entries.return_value = 1
            entry_qs = Entry.objects.filter(pk=entry.pk)
            with mock.patch(
                    "registrations.models.Entry.objects.filter") as qs_mock:
                qs_mock.return_value = entry_qs
                qs_mock.get = Mock(return_value=entry_qs.get())

                request = self.rf.post(
                    f"/registration/admin/process/{entry.pk}/", {
                        "action": "reject",
                    })
                request.user = _get_mock_user()
                request.member = request.user
                request._messages = Mock()
                response = self.view.post(request, pk=entry.pk)

                self.assertEqual(response.status_code, 302)

                self.assertEqual(
                    response.url,
                    f"/admin/registrations/{reg_type}/{entry.pk}/change/",
                )

                reject_entries.assert_called_once_with(1, entry_qs)
                self.assertFalse(accept_entries.called)

                request._messages.add.assert_called_once_with(
                    messages.SUCCESS,
                    _("Successfully rejected %s.") %
                    model_ngettext(entry_qs.all()[0], 1),
                    "",
                )

                reject_entries.return_value = 0
                self.view.post(request, pk=entry.pk)

                request._messages.add.assert_any_call(
                    messages.ERROR,
                    _("Could not reject %s.") %
                    model_ngettext(entry_qs.all()[0], 1),
                    "",
                )

    @mock.patch("registrations.emails.send_registration_email_confirmation")
    def test_post_resend(self, send_email):
        self.view.action = "resend"
        for reg_type, entry in {
                "registration": self.entry1,
                "renewal": self.entry2,
        }.items():
            entry_qs = Entry.objects.filter(pk=entry.pk)
            send_email.reset_mock()
            send_email.return_value = None
            with mock.patch(
                    "registrations.models.Entry.objects.filter") as qs_mock:
                qs_mock.return_value = entry_qs
                qs_mock.get = Mock(return_value=entry_qs.get())

                request = self.rf.post(
                    f"/registration/admin/process/{entry.pk}/", {
                        "action": "resend",
                    })
                request.user = _get_mock_user()
                request.member = request.user
                request._messages = Mock()
                response = self.view.post(request, pk=entry.pk)

                self.assertEqual(response.status_code, 302)
                self.assertEqual(
                    response.url,
                    f"/admin/registrations/{reg_type}/{entry.pk}/change/",
                )

                if reg_type == "registration":
                    send_email.assert_called_once_with(entry)
                elif reg_type == "renewal":
                    send_email.assert_not_called()

    @mock.patch("registrations.services.revert_entry")
    def test_post_revert(self, revert):
        self.view.action = "revert"
        for reg_type, entry in {
                "registration": self.entry1,
                "renewal": self.entry2,
        }.items():
            entry_qs = Entry.objects.filter(pk=entry.pk)
            revert.reset_mock()
            revert.return_value = None
            with mock.patch(
                    "registrations.models.Entry.objects.filter") as qs_mock:
                qs_mock.return_value = entry_qs
                qs_mock.get = Mock(return_value=entry_qs.get())

                request = self.rf.post(
                    f"/registration/admin/process/{entry.pk}/", {
                        "action": "revert",
                    })
                request.user = _get_mock_user()
                request.member = request.user
                request._messages = Mock()
                response = self.view.post(request, pk=entry.pk)

                self.assertEqual(response.status_code, 302)
                self.assertEqual(
                    response.url,
                    f"/admin/registrations/{reg_type}/{entry.pk}/change/",
                )

                revert.assert_called_once_with(1, entry.entry_ptr)

    @mock.patch("registrations.models.Entry.objects.filter")
    def test_post_not_exists(self, qs_mock):
        qs_mock.return_value = MagicMock(get=Mock(
            side_effect=Entry.DoesNotExist,
            return_value=4,
        ))

        request = self.rf.post("/registration/admin/process/1234/",
                               {"action": "accept"})
        request.user = _get_mock_user()
        request.member = request.user
        request._messages = Mock()
        response = self.view.post(request, pk=4)

        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, reverse("admin:index"))

    @mock.patch("registrations.services.accept_entries")
    @mock.patch("registrations.services.reject_entries")
    def test_post_no_action(self, reject_entries, accept_entries):
        self.view.action = None
        for reg_type, entry in {
                "registration": self.entry1,
                "renewal": self.entry2,
        }.items():
            entry_qs = Entry.objects.filter(pk=entry.pk)
            accept_entries.reset_mock()
            accept_entries.return_value = 1
            reject_entries.reset_mock()
            reject_entries.return_value = 1
            with mock.patch(
                    "registrations.models.Entry.objects.filter") as qs_mock:
                qs_mock.return_value = entry_qs
                qs_mock.get = Mock(return_value=entry_qs.get())

                request = self.rf.post(
                    f"/registration/admin/process/{entry.pk}/", )
                request.user = _get_mock_user()
                request.member = request.user
                request._messages = Mock()
                response = self.view.post(request, pk=entry.pk)

                self.assertFalse(reject_entries.called)
                self.assertFalse(accept_entries.called)

                self.assertEqual(response.status_code, 302)
                self.assertEqual(
                    response.url,
                    f"/admin/registrations/{reg_type}/{entry.pk}/change/",
                )
    def test(self):

        # Update ambulance a1
        a = self.a1
        user = self.u1

        status = AmbulanceStatus.AH.name
        serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id),
                                         data={
                                             'status': status,
                                         },
                                         partial=True)
        serializer.is_valid()
        serializer.save(updated_by=user)

        timestamp = timezone.now()
        location = {'latitude': -2., 'longitude': 7.}

        serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id),
                                         data={
                                             'location': location,
                                             'timestamp': timestamp
                                         },
                                         partial=True)
        serializer.is_valid()
        serializer.save(updated_by=user)

        status = AmbulanceStatus.OS.name
        serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id),
                                         data={
                                             'status': status,
                                         },
                                         partial=True)
        serializer.is_valid()
        serializer.save(updated_by=user)

        # This update does not go to AmbulanceUpdate!
        serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id),
                                         data={
                                             'identifier': 'someid',
                                         },
                                         partial=True)
        serializer.is_valid()
        serializer.save(updated_by=user)

        # test AmbulanceUpdateSerializer
        queryset = AmbulanceUpdate.objects.filter(ambulance=a)
        answer1 = []
        for u in queryset:
            serializer = AmbulanceUpdateSerializer(u)
            result = {
                'id': u.id,
                'ambulance_id': u.ambulance.id,
                'ambulance_identifier': u.ambulance.identifier,
                'comment': u.comment,
                'capability': u.capability,
                'status': u.status,
                'orientation': u.orientation,
                'location': point2str(u.location),
                'timestamp': date2iso(u.timestamp),
                'updated_by_username': u.updated_by.username,
                'updated_on': date2iso(u.updated_on)
            }
            answer1.append(serializer.data)
            self.assertDictEqual(serializer.data, result)

        # Update ambulance a2
        a = self.a3
        user = self.u3

        status = AmbulanceStatus.AH.name
        serializer = AmbulanceSerializer(a,
                                         data={
                                             'status': status,
                                         },
                                         partial=True)
        serializer.is_valid()
        serializer.save(updated_by=user)

        timestamp = timezone.now()
        location = {'latitude': -2., 'longitude': 7.}

        serializer = AmbulanceSerializer(a,
                                         data={
                                             'location': location,
                                             'timestamp': timestamp
                                         },
                                         partial=True)
        serializer.is_valid()
        serializer.save(updated_by=user)

        status = AmbulanceStatus.OS.name
        serializer = AmbulanceSerializer(a,
                                         data={
                                             'status': status,
                                         },
                                         partial=True)
        serializer.is_valid()
        serializer.save(updated_by=user)

        # test AmbulanceUpdateSerializer
        queryset = AmbulanceUpdate.objects.filter(ambulance=a)
        answer3 = []
        for u in queryset:
            serializer = AmbulanceUpdateSerializer(u)
            result = {
                'id': u.id,
                'ambulance_id': u.ambulance.id,
                'ambulance_identifier': a.identifier,
                'comment': u.comment,
                'capability': u.capability,
                'status': u.status,
                'orientation': u.orientation,
                'location': point2str(u.location),
                'timestamp': date2iso(u.timestamp),
                'updated_by_username': u.updated_by.username,
                'updated_on': date2iso(u.updated_on)
            }
            answer3.append(serializer.data)
            self.assertDictEqual(serializer.data, result)

        # Test api

        # instantiate client
        client = Client()

        # login as admin
        client.login(username=settings.MQTT['USERNAME'],
                     password=settings.MQTT['PASSWORD'])

        # retrieve ambulances updates
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a1.id),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertCountEqual(result, answer1)
        self.assertEqual(len(result), 4)

        # retrieve ambulances updates
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a3.id),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertCountEqual(result, answer3)
        self.assertEqual(len(result), 4)

        # logout
        client.logout()

        # login as testuser1
        client.login(username='******', password='******')

        # retrieve ambulances
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a1.id),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # retrieve ambulances
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a3.id),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # logout
        client.logout()

        # login as testuser2
        client.login(username='******', password='******')

        # retrieve ambulances
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a1.id),
                              follow=True)
        self.assertEqual(response.status_code, 404)

        # retrieve ambulances updates
        response = client.get('/en/api/ambulance/{}/updates/'.format(
            self.a3.id),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertCountEqual(result, answer3)
        self.assertEqual(len(result), 4)

        # logout
        client.logout()
Beispiel #52
0
class ReferenceCreateViewTest(TestCase):
    """
    Test for the ReferenceCreateView
    """

    fixtures = ["members.json"]

    @classmethod
    def setUpTestData(cls):
        cls.login_user = Member.objects.filter(last_name="Wiggers").first()
        cls.registration = Registration.objects.create(
            first_name="John",
            last_name="Doe",
            email="*****@*****.**",
            programme="computingscience",
            student_number="s1234567",
            starting_year=2014,
            address_street="Heyendaalseweg 135",
            address_street2="",
            address_postal_code="6525AJ",
            address_city="Nijmegen",
            address_country="NL",
            phone_number="06123456789",
            birthday=timezone.now().replace(year=1990, day=1),
            length=Entry.MEMBERSHIP_YEAR,
            contribution=7.50,
            membership_type=Membership.BENEFACTOR,
            status=Entry.STATUS_CONFIRM,
        )
        cls.new_user = get_user_model().objects.create_user(
            username="******", first_name="Johnny", last_name="Test")
        cls.renewal = Renewal.objects.create(
            length=Entry.MEMBERSHIP_YEAR,
            contribution=7.50,
            membership_type=Membership.BENEFACTOR,
            status=Entry.STATUS_CONFIRM,
            member=cls.new_user,
        )

    def setUp(self):
        self.rf = RequestFactory()
        self.view = views.ReferenceCreateView()
        self.client = Client()
        self.client.force_login(self.login_user)

    def test_not_logged_in(self):
        """
        If there is no logged-in user they should redirect
        to the authentication page
        """
        self.client.logout()

        response = self.client.get(
            reverse("registrations:reference", args=(self.registration.pk, )),
            follow=True,
        )
        self.assertEqual(200, response.status_code)
        self.assertEqual(
            [(
                "/user/login/?next=" + reverse("registrations:reference",
                                               args=(self.registration.pk, )),
                302,
            )],
            response.redirect_chain,
        )

    def test_not_a_current_member(self):
        """
        If the logged-in user is not a member they should not be able to visit
        this page
        """
        self.client.logout()
        self.client.force_login(self.new_user)

        response = self.client.get(
            reverse("registrations:reference", args=(self.registration.pk, )))
        self.assertEqual(403, response.status_code)

    def test_entry_does_not_exist(self):
        """
        If the registration/renewal does not exist a 404 should be shown
        """
        response = self.client.get(
            reverse(
                "registrations:reference",
                args=("00000000-0000-0000-0000-000000000000", ),
            ))
        self.assertEqual(404, response.status_code)

    def test_entry_no_references_required(self):
        """
        If the registration/renewal does not require references
        a 404 should be shown
        """
        self.registration.no_references = True
        self.registration.save()

        response = self.client.get(
            reverse("registrations:reference", args=(self.registration.pk, )))
        self.assertEqual(404, response.status_code)

    def test_entry_no_benefactor(self):
        """
        If the registration/renewal is not a the benefactor type
        a 404 should be shown
        """
        self.registration.membership_type = Membership.MEMBER
        self.registration.save()

        response = self.client.get(
            reverse("registrations:reference", args=(self.registration.pk, )))
        self.assertEqual(404, response.status_code)

    def test_entry_shows_info(self):
        """
        If everything is alright the info and submission buttons should
        be shown
        """
        with self.subTest("Registration"):
            response = self.client.get(
                reverse("registrations:reference",
                        args=(self.registration.pk, )))
            self.assertEqual(200, response.status_code)
            self.assertEqual("John Doe", response.context["name"])
            self.assertEqual(False, response.context["success"])
            self.assertContains(
                response,
                "<strong>John Doe</strong> wants to become a benefactor")

        with self.subTest("Renewal"):
            response = self.client.get(
                reverse("registrations:reference", args=(self.renewal.pk, )))
            self.assertEqual(200, response.status_code)
            self.assertEqual("Johnny Test", response.context["name"])
            self.assertEqual(False, response.context["success"])
            self.assertContains(
                response,
                "<strong>Johnny Test</strong> wants to become a benefactor")

    def test_entry_saves_correctly(self):
        """
        If a entry is saved it should redirect to the success page
        which should show the right content. And the Reference object
        should be saved.
        """
        response = self.client.post(
            reverse("registrations:reference", args=(self.registration.pk, )),
            follow=True,
        )
        self.assertEqual(200, response.status_code)
        self.assertEqual(
            [(
                reverse("registrations:reference-success",
                        args=(self.registration.pk, )),
                302,
            )],
            response.redirect_chain,
        )
        self.assertEqual("John Doe", response.context["name"])
        self.assertEqual(True, response.context["success"])
        self.assertContains(response, "Your reference has been saved.")

        self.assertTrue(
            Reference.objects.filter(member=self.login_user,
                                     entry=self.registration).exists())

    def test_entry_reference_exists(self):
        """
        If there is already a reference for an entry then the page should
        show an error and not redirect.
        """
        Reference.objects.create(member=self.login_user,
                                 entry=self.registration)

        response = self.client.post(
            reverse("registrations:reference", args=(self.registration.pk, )),
            follow=True,
        )
        self.assertEqual(200, response.status_code)
        self.assertEqual([], response.redirect_chain)
        self.assertEqual(
            {"__all__": ["You've already given a reference for this person."]},
            response.context["form"].errors,
        )
        self.assertEqual(False, response.context["success"])
        self.assertContains(
            response, "You&#x27;ve already given a reference for this person.")
    def test_ambulance_patch_viewset(self):

        # instantiate client
        client = Client()

        # login as admin
        client.login(username=settings.MQTT['USERNAME'],
                     password=settings.MQTT['PASSWORD'])

        # retrieve ambulance
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(self.a1).data
        self.assertDictEqual(result, answer)

        # set status ambulance
        status = AmbulanceStatus.OS.name
        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a1.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'status': status,
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a1.id)).data
        self.assertDictEqual(result, answer)

        # retrieve new ambulance status
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertEqual(result['status'], status)

        # set status location
        timestamp = timezone.now()
        location = {'latitude': -2., 'longitude': 7.}

        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a1.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'location':
                                    point2str(location),
                                    'timestamp':
                                    date2iso(timestamp),
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a1.id)).data
        if math.fabs(answer['orientation'] - result['orientation']) < 1e-4:
            answer['orientation'] = result['orientation']
        self.assertDictEqual(result, answer)

        # retrieve new ambulance location
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)))
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertEqual(result['status'], status)
        self.assertEqual(result['location'], point2str(location))
        self.assertEqual(result['timestamp'], date2iso(timestamp))

        # set wrong attribute
        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a1.id)),
                                content_type='application/json',
                                data=json.dumps({'status': 'will fail'}),
                                follow=True)
        self.assertEqual(response.status_code, 400)

        # set wrong ambulance id
        response = client.patch('/en/api/ambulance/100/',
                                data=json.dumps({'status': status}),
                                follow=True)
        self.assertEqual(response.status_code, 404)

        # logout
        client.logout()

        # login as testuser2
        client.login(username='******', password='******')

        # retrieve ambulance
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(self.a3).data
        self.assertDictEqual(result, answer)

        # set status ambulance
        status = AmbulanceStatus.OS.name
        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a3.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'status': status,
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data
        self.assertDictEqual(result, answer)

        # retrieve new ambulance status
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertEqual(result['status'], status)

        # set location
        timestamp = timezone.now()
        location = {'latitude': -2., 'longitude': 7.}

        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a3.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'location':
                                    point2str(location),
                                    'timestamp':
                                    date2iso(timestamp),
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data
        if math.fabs(answer['orientation'] - result['orientation']) < 1e-4:
            answer['orientation'] = result['orientation']
        self.assertDictEqual(result, answer)

        # retrieve new ambulance location
        response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)),
                              follow=True)
        self.assertEqual(response.status_code, 200)
        result = JSONParser().parse(BytesIO(response.content))
        self.assertEqual(result['status'], status)
        self.assertEqual(result['location'], point2str(location))
        self.assertEqual(result['timestamp'], date2iso(timestamp))

        # set status ambulance
        status = AmbulanceStatus.OS.name
        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a1.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'status': status,
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 404)

        # set status ambulance
        status = AmbulanceStatus.OS.name
        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a2.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'status': status,
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 404)

        # logout
        client.logout()

        # login as testuser1
        client.login(username='******', password='******')

        # set status ambulance
        status = AmbulanceStatus.OS.name
        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a1.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'status': status,
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 404)

        # set status ambulance
        status = AmbulanceStatus.OS.name
        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a2.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'status': status,
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 404)

        # set status ambulance
        status = AmbulanceStatus.OS.name
        response = client.patch('/en/api/ambulance/{}/'.format(str(
            self.a3.id)),
                                content_type='application/json',
                                data=json.dumps({
                                    'status': status,
                                }),
                                follow=True)
        self.assertEqual(response.status_code, 404)

        # logout
        client.logout()
Beispiel #54
0
class TestViews(TestCase):
    """Testing Views with Client without launching server"""
    def setUp(self):
        self.client = Client()
        self.snake_family_name = Family.objects.create(name='Family_For_All')
        self.snake_specia_name = 'Snake_For_All'
        self.specia_1 = Specia.objects.create(
            name=self.snake_specia_name,
            family=self.snake_family_name,
        )
        self.snake_name_1 = 'Varga'
        self.snake = Snake.objects.create(
            name=self.snake_name_1,
            specia=self.specia_1
        )

    def test_index(self):
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)
        # self.assertEqual(response.status_code, 201)
        encoding = 'utf-8'
        text = response.content.decode(encoding)
        searched = '<button type="submit" class="btn btn-primary">Save and send</button>'
        # check if buttons exist in the page
        self.assertTrue(searched in text)
        # print(response.context)
        self.assertTrue('object_list' in response.context.keys())
        self.assertTrue('active_page' in response.context.keys())
        self.assertEqual(response.context['active_page'], "1")


    # Что желательно проверить в views
    # 1. status code для разных пользователей
    # 2. Проверка создаваемых из форм объектов
    # 3. Контекст

    def test_permissions(self):
        # авторизация пользователя
        admin = User.objects.create_superuser('admin', '*****@*****.**', '12345678qwerty')
        staff = User.objects.create_user('staff', '*****@*****.**', '12345678qwerty', is_staff=True)
        user = User.objects.create_user('user', '*****@*****.**', '12345678qwerty', is_staff=False)
        # snake/<int:pk>/delete/
        url = f'/snake/{self.snake.id}/delete/'
        response = self.client.get(url)
        self.assertEqual(response.status_code, 302)

        # for admin
        self.client.login(username='******', password='******')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.client.logout()

        # for staff
        self.client.login(username='******', password='******')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 403)

        url = '/create/'
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.client.logout()

        # for user
        self.client.login(username='******', password='******')
        url = '/create/'
        response = self.client.get(url)
        self.assertEqual(response.status_code, 403)
        self.client.logout()
Beispiel #55
0
class TestImagesViews(TestCase):
    """Class to test image views."""
    @classmethod
    def setUp(self):
        user = User(username='******', email='*****@*****.**')
        user.save()
        self.user = user
        self.client = Client()

        photo = PhotoFactory.build()
        photo.user_id = self.user.id
        photo.save()
        self.photo = photo

        album = AlbumFactory.build()
        album.user_id = self.user.id
        album.save()
        self.album = album

        self.request = RequestFactory()

    @classmethod
    def tearDown(self):
        """Teardown class for test users."""
        User.objects.all().delete()
        super(TestCase, self)

    def test_200_status_on_authenticated_request_to_library(self):
        """Check for 200 status code."""
        self.client.force_login(self.user)
        response = self.client.get(reverse_lazy('library'))
        self.client.logout()
        self.assertEqual(response.status_code, 200)

    def test_302_status_on_unauthenticated_request_to_library(self):
        """Check for 302 status code."""
        response = self.client.get(reverse_lazy('library'))
        self.assertEqual(response.status_code, 302)

    def test_get_library_page_404_status_code(self):
        """Test library page view returns 404 status code."""
        self.client.force_login(self.user)
        response = self.client.get('images/libary/', follow=True)
        self.assertEqual(response.status_code, 404)

    def test_get_library_page_templates(self):
        """Test library page view templates."""
        self.client.force_login(self.user)
        response = self.client.get(reverse_lazy('library'), follow=True)
        self.assertEqual(response.templates[0].name, 'images/library.html')
        self.assertEqual(response.templates[1].name, 'base.html')

    def test_200_status_on_authenticated_request_to_albums(self):
        """Check for 200 status code."""
        self.client.force_login(self.user)
        response = self.client.get(reverse_lazy('albums'))
        self.client.logout()
        self.assertEqual(response.status_code, 200)

    def test_302_status_on_unauthenticated_request_to_albums(self):
        """Check for 302 status code."""
        response = self.client.get(reverse_lazy('albums'))
        self.assertEqual(response.status_code, 302)

    def test_get_albums_page_404_status_code(self):
        """Test library page view returns 404 status code."""
        self.client.force_login(self.user)
        response = self.client.get('images/alum', follow=True)
        self.assertEqual(response.status_code, 404)

    def test_get_album_page_templates(self):
        """Test library page view templates."""
        self.client.force_login(self.user)
        response = self.client.get(reverse_lazy('albums'), follow=True)
        self.assertEqual(response.templates[0].name, 'images/albums.html')
        self.assertEqual(response.templates[1].name, 'base.html')

    def test_200_status_on_authenticated_request_to_photos(self):
        """Check for 200 status code."""
        self.client.force_login(self.user)
        response = self.client.get(reverse_lazy('photos'))
        self.client.logout()
        self.assertEqual(response.status_code, 200)

    def test_302_status_on_unauthenticated_request_to_photos(self):
        """Check for 302 status code."""
        response = self.client.get(reverse_lazy('photos'))
        self.assertEqual(response.status_code, 302)

    def test_get_photos_page_404_status_code(self):
        """Test library page view returns 404 status code."""
        self.client.force_login(self.user)
        response = self.client.get('images/photogs/', follow=True)
        self.assertEqual(response.status_code, 404)

    def test_get_photos_page_templates(self):
        """Test library page view templates."""
        self.client.force_login(self.user)
        response = self.client.get(reverse_lazy('photos'), follow=True)
        self.assertEqual(response.templates[0].name, 'images/photos.html')
        self.assertEqual(response.templates[1].name, 'base.html')

    def test_200_status_on_authenticated_request_to_image(self):
        """Test 200 status code on authenticated request to single image."""
        self.client.force_login(self.user)
        response = self.client.get('/images/photos/{}'.format(self.photo.id))
        self.client.logout()
        self.assertEqual(response.status_code, 200)

    def test_302_status_on_unauthenticated_request_to_image(self):
        """Test 200 status code on authenticated request to single image."""
        response = self.client.get('/images/photos/{}'.format(self.photo.id))
        self.assertEqual(response.status_code, 302)

    def test_404_status_on_bad_request_to_image(self):
        """Test bad photo page view returns 404 status code."""
        response = self.client.get('/images/photos/does_not_exist')
        self.assertEqual(response.status_code, 404)

    def test_get_photo_edit_page_templates(self):
        """Test library page view templates."""
        self.client.force_login(self.user)
        response = self.client.get('/images/photos/{}/edit'.format(
            self.photo.id))
        self.assertEqual(response.templates[0].name, 'images/photo_edit.html')
        self.assertEqual(response.templates[1].name, 'base.html')

    def test_200_status_on_authenticated_request_to_edit_image(self):
        """Test 200 status code on authenticated request to edit album page."""
        self.client.force_login(self.user)
        response = self.client.get('/images/photos/{}/edit'.format(
            self.photo.id))
        self.client.logout()
        self.assertEqual(response.status_code, 200)

    def test_302_status_on_unauthenticated_request_to_edit_image(self):
        """Test 302 status code on unauthenticated request to edit album page."""
        response = self.client.get('/images/photos/{}/edit'.format(
            self.photo.id))
        self.assertEqual(response.status_code, 302)

    def test_unauth_user_redirected_to_login_on_photo_edit_page(self):
        """Test unauthorized user is redirected to login page."""
        response = self.client.get('/images/photos/{}/edit'.format(
            self.photo.id),
                                   follow=True)
        self.assertEqual(response.templates[0].name, 'registration/login.html')
        self.assertEqual(response.templates[1].name, 'base.html')

    def test_200_status_on_authenticated_request_to_album(self):
        """Test 200 status code on authenticated request to single album."""
        self.client.force_login(self.user)
        response = self.client.get('/images/albums/{}'.format(self.album.id))
        self.client.logout()
        self.assertEqual(response.status_code, 200)

    def test_302_status_on_unauthenticated_request_to_album(self):
        """Test 302 status code on unauthenticated request to single album."""
        response = self.client.get('/images/albums/{}'.format(self.album.id))
        self.assertEqual(response.status_code, 302)

    def test_404_status_on_bad_request_to_album(self):
        """Test bad photo page view returns 404 status code."""
        response = self.client.get('/images/albums/does_not_exist')
        self.assertEqual(response.status_code, 404)

    def test_200_status_on_authenticated_request_to_edit_album(self):
        """Test 200 status code on authenticated request to edit album page."""
        self.client.force_login(self.user)
        response = self.client.get('/images/albums/{}/edit'.format(
            self.album.id))
        self.client.logout()
        self.assertEqual(response.status_code, 200)

    def test_302_status_on_unauthenticated_request_to_edit_album(self):
        """Test 302 status code on unauthenticated request to edit album page."""
        response = self.client.get('/images/albums/{}/edit'.format(
            self.album.id))
        self.assertEqual(response.status_code, 302)

    def test_unauth_user_redirected_to_login_on_album_edit_page(self):
        """Test unauthorized user is redirected to login page."""
        response = self.client.get('/images/albums/{}/edit'.format(
            self.album.id),
                                   follow=True)
        self.assertEqual(response.templates[0].name, 'registration/login.html')
        self.assertEqual(response.templates[1].name, 'base.html')
Beispiel #56
0
class UserProfileTests(TestCase):
    def setUp(self):

        self.newuser = get_user_model().objects.create_user(
            email='*****@*****.**',
            password='******',
            short_name='new',
            full_name='new user')
        self.client = Client()
        self.basedir = os.path.dirname(os.path.dirname(__file__))

    def login_newuser(self):
        self.client.logout()
        response = self.client.post(reverse('friendly_login'), {
            'username': '******',
            'password': '******'
        })
        self.assertEqual(response.status_code, 302)
        return response

    def post_with_profile_picture(self, formdata, code=302):

        path_to_pic = os.path.join(self.basedir, 'fixtures/aristotle.png')

        with open(path_to_pic, mode='br') as fp:
            formdata.update({'profile_picture': fp})
            response = self.client.post(reverse('aristotle_mdr:userEdit'),
                                        formdata)
            self.assertEqual(response.status_code, code)

        return response

    def get_initial(self):
        response = self.client.get(reverse('aristotle_mdr:userEdit'))
        self.assertEqual(response.status_code, 200)

        # Get initial form data
        initial = response.context['form'].initial
        return initial

    def test_load_profile(self):

        self.login_newuser()
        response = self.client.get(reverse('aristotle_mdr:userProfile'))
        self.assertEqual(response.status_code, 200)

    def test_load_profile_content(self):
        self.login_newuser()
        response = self.client.get(reverse('aristotle_mdr:userProfile'))

        # check dynamic picture loaded
        dynamic_picture_url = reverse('aristotle_mdr:dynamic_profile_picture',
                                      args=[self.newuser.id])
        self.assertContains(response, dynamic_picture_url)

        # check sessions context
        self.assertEqual(len(response.context['sessions']), 1)

    def test_load_edit_page(self):

        self.login_newuser()
        response = self.client.get(reverse('aristotle_mdr:userEdit'))
        self.assertEqual(response.status_code, 200)

        # Check initial is set properly
        initial = response.context['form'].initial
        self.assertEqual(initial['email'], '*****@*****.**')
        self.assertEqual(initial['short_name'], 'new')
        self.assertEqual(initial['full_name'], 'new user')
        self.assertFalse('profilePicture' in initial)

    def test_profile_upload(self):

        self.login_newuser()

        initial = self.get_initial()
        response = self.post_with_profile_picture(initial)

        user = get_user_model().objects.get(email='*****@*****.**')

        self.assertTrue(user.profile.profilePicture)
        self.assertTrue(
            user.profile.profilePicture.name.startswith('aristotle'))
        self.assertEqual(user.profile.profilePictureWidth, 256)
        self.assertTrue(user.profile.profilePictureHeight)

    def test_profile_upload_with_clear(self):

        self.login_newuser()

        initial = self.get_initial()

        initial.update({'profile_picture-clear': 'on'})

        response = self.client.post(reverse('aristotle_mdr:userEdit'), initial)

    def test_save_without_changes(self):

        self.login_newuser()

        initial = self.get_initial()
        response = self.post_with_profile_picture(initial)

        # Post form again, with no changes
        complete_initial = self.get_initial()
        response = self.client.post(reverse('aristotle_mdr:userEdit'),
                                    complete_initial)
        self.assertEqual(response.status_code, 302)

    def test_default_profile_picture(self):

        # check page load
        response = self.client.get(
            reverse('aristotle_mdr:dynamic_profile_picture', args=[3]))
        self.assertEqual(response.status_code, 200)

        three_toga_color = response.context['toga_color']
        three_headshot_color = response.context['headshot_color']

        # check diffent args returns new colors
        response = self.client.get(
            reverse('aristotle_mdr:dynamic_profile_picture', args=[4]))
        self.assertEqual(response.status_code, 200)

        self.assertNotEqual(three_toga_color, response.context['toga_color'])
        self.assertNotEqual(three_headshot_color,
                            response.context['headshot_color'])

        # check second request with same args returns same colors
        response = self.client.get(
            reverse('aristotle_mdr:dynamic_profile_picture', args=[3]))
        self.assertEqual(response.status_code, 200)

        self.assertEqual(three_toga_color, response.context['toga_color'])
        self.assertEqual(three_headshot_color,
                         response.context['headshot_color'])
Beispiel #57
0
class ViewsHomeTest(TestCase):
    fixtures = ['init', 'crontab', 'test-rules-source']

    def setUp(self):
        self.client = Client()
        User.objects.create_superuser(username='******',
                                      password='******',
                                      email='*****@*****.**')
        if not self.client.login(username='******', password='******'):
            self.assertRaises(Exception("Not logged"))

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

    def test_login(self):
        """
        Django Admin login
        """
        response = self.client.get('/admin/login/', follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertIn(
            '<title>Site administration | Probe Manager site admin</title>',
            str(response.content))
        self.assertEqual('admin/index.html', response.templates[0].name)
        self.assertIn('admin', response.resolver_match.app_names)
        self.assertIn('function AdminSite.index',
                      str(response.resolver_match.func))

        response = self.client.get('/admin/')
        self.assertEqual(response.status_code, 200)
        self.assertIn(
            '<a href="/admin/auth/user/" class="changelink">Change</a>',
            str(response.content))
        self.assertEqual(str(response.context['user']), 'testuser')
        with self.assertTemplateUsed('admin/index.html'):
            self.client.get('/admin/login/', follow=True)

        client_not_logged = Client()
        response = client_not_logged.get('/admin/login/', follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertIn('<title>Log in | Probe Manager site admin</title>',
                      str(response.content))

        response = client_not_logged.get('/admin/', follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertIn('<title>Log in | Probe Manager site admin</title>',
                      str(response.content))
        self.assertEqual(str(response.context['user']), 'AnonymousUser')
        response = client_not_logged.get('/admin/')
        self.assertRedirects(response,
                             expected_url='/admin/login/?next=/admin/',
                             status_code=302,
                             target_status_code=200)
        with self.assertTemplateUsed('admin/login.html'):
            client_not_logged.get('/admin/', follow=True)

    def test_index(self):
        """
        Home page
        """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)
        self.assertIn('<title>Home</title>', str(response.content))
        self.assertEqual('home/index.html', response.templates[0].name)
        self.assertIn('home', response.resolver_match.app_names)
        self.assertIn('function index', str(response.resolver_match.func))
        self.assertEqual(str(response.context['user']), 'testuser')
        with self.assertTemplateUsed('home/index.html'):
            self.client.get('/')
Beispiel #58
0
class EventTest(TestCase):
    fixtures = ['user.json', 'socialapp.json']

    def setUp(self):
        self.client = Client()
        self.event_data = EVENT_DATA.copy()
        self.proposal_data = PROPOSAL_DATA.copy()
        self.client.login(username='******', password='******')

    def test_create_event(self):
        response = self.client.post(reverse('create_event'),
                                    self.event_data, follow=True)
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(Event.objects.all(),
                                 ["<Event: RuPy>"])
        self.assertQuerysetEqual(response.context['request'].user.events.all(),
                                 ["<Event: RuPy>"])

        event = response.context['event']
        self.assertEquals('RuPy', event.title)
        self.assertEquals('A really good event.', event.description)
        self.assertEquals('admin', event.author.username)
        self.assertEquals(False, event.is_published)

    def test_notify_event_creator_after_creation(self):
        self.client.post(reverse('create_event'), self.event_data)
        event = Event.objects.get()

        self.assertEqual(1, len(mail.outbox))
        email = mail.outbox[0]
        self.assertIn(event.author.email, email.recipients())
        self.assertIn(settings.NO_REPLY_EMAIL, email.from_email)

    def test_create_event_with_jury(self):
        event_data = self.event_data.copy()

        response = self.client.post(reverse('create_event'),
                                    event_data, follow=True)
        self.assertEquals(200, response.status_code)

        event = response.context['event']
        self.assertEquals(Jury.objects.count(), 1)
        self.assertQuerysetEqual(event.jury.users.all(), ['<User: admin>'])

    def test_anonymous_user_create_events(self):
        self.client.logout()
        response = self.client.post(reverse('create_event'),
                                    self.event_data, follow=True)
        self.assertEquals(200, response.status_code)
        self.assertEquals(reverse('create_event'),
                          response.context_data.get('redirect_field_value'))
        self.assertEquals(0, Event.objects.count())

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

        Event.objects.create(**self.event_data)
        response = self.client.get(reverse('list_events'), follow=True)
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_list'], [])

    def test_list_event(self):
        event_data = self.event_data.copy()
        event_data.update(is_published=True)
        Event.objects.create(**event_data)

        response = self.client.get(reverse('list_events'), follow=True)
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(response.context['event_list'],
                                 ["<Event: RuPy>"])

    def test_detail_event(self):
        event = Event.objects.create(**self.event_data)
        response = self.client.get(
            reverse('view_event', kwargs={'slug': event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)

        event = response.context['event']
        self.assertEquals('RuPy', event.title)
        self.assertEquals('A really good event.', event.description)

    def test_detail_from_an_event_with_now_allow_public_voting(self):
        self.client.logout()
        event_data = self.event_data.copy()
        event_data.update(allow_public_voting=False)
        event = Event.objects.create(**event_data)
        response = self.client.get(
            reverse('view_event', kwargs={'slug': event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual([], response.context['event_proposals'])

    def test_update_event(self):
        event = Event.objects.create(**self.event_data)
        self.assertEquals(1, Event.objects.count())

        new_event_data = self.event_data.copy()
        new_event_data['description'] = 'A really really good event.'

        self.assertEquals(self.event_data['description'], event.description)
        response = self.client.post(reverse('update_event',
                                            kwargs={'slug': event.slug}),
                                    new_event_data, follow=True)

        self.assertEquals(200, response.status_code)
        event = response.context['event']
        self.assertEquals('RuPy', event.title)
        self.assertEquals('A really really good event.',
                          event.description)

    def test_update_event_title(self):
        event = Event.objects.create(**self.event_data)
        new_event_data = self.event_data.copy()
        new_event_data['title'] = 'RuPy 2014'

        self.assertEquals(self.event_data['title'], event.title)
        response = self.client.post(
            reverse('update_event', kwargs={'slug': event.slug}),
            new_event_data, follow=True
        )

        self.assertEquals(200, response.status_code)
        event = response.context['event']
        self.assertEquals('rupy-2014', event.slug)

    def test_anonymous_user_update_events(self):
        self.client.logout()
        event = Event.objects.create(**self.event_data)
        event_update_url = reverse('update_event',
                                   kwargs={'slug': event.slug})
        new_event_data = self.event_data.copy()
        new_event_data['title'] = 'RuPy 2014'
        response = self.client.post(
            event_update_url,
            new_event_data, follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertEquals(event_update_url,
                          response.context_data.get('redirect_field_value'))
        self.assertEquals('RuPy', event.title)

    def test_not_author_update_events(self):
        self.client.login(username='******', password='******')
        event = Event.objects.create(**self.event_data)
        event_update_url = reverse('update_event',
                                   kwargs={'slug': event.slug})
        new_event_data = self.event_data.copy()
        new_event_data['title'] = 'RuPy 2014'
        response = self.client.post(
            event_update_url,
            new_event_data, follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertEquals('event/event_detail.html', response.template_name[0])
        self.assertEquals('RuPy', event.title)

    def test_publish_event(self):
        event = Event.objects.create(**self.event_data)
        event_data = self.event_data.copy()
        event_data['is_published'] = True

        self.assertEquals(False, event.is_published)
        response = self.client.post(
            reverse('update_event', kwargs={'slug': event.slug}),
            event_data, follow=True
        )

        self.assertEquals(200, response.status_code)
        event = response.context['event']
        self.assertEquals(True, event.is_published)

    def test_event_create_event_proposal_context(self):
        event = Event.objects.create(**self.event_data)
        response = self.client.get(
            reverse('create_event_proposal', kwargs={'slug': event.slug}),
            follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertEquals(event, response.context['event'])

    def test_event_create_event_proposal(self):
        event = Event.objects.create(**self.event_data)
        response = self.client.post(
            reverse('create_event_proposal', kwargs={'slug': event.slug}),
            self.proposal_data, follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertQuerysetEqual(Proposal.objects.all(),
                                 ["<Proposal: Python For Zombies>"])
        self.assertQuerysetEqual(event.proposals.all(),
                                 ["<Proposal: Python For Zombies>"])

        python_for_zombies = event.proposals.get()
        self.assertEquals('Python For Zombies', python_for_zombies.title)
        self.assertEquals('Brain...', python_for_zombies.description)

    def test_notify_event_jury_and_proposal_author_on_new_proposal(self):
        event = Event.objects.create(**self.event_data)
        self.client.post(
            reverse('create_event_proposal', kwargs={'slug': event.slug}),
            self.proposal_data, follow=True
        )
        proposal = event.proposals.get()

        self.assertEqual(2, len(mail.outbox))
        jury_email = mail.outbox[0]
        for jury in event.jury.users.all():
            self.assertIn(jury.email, jury_email.recipients())
        self.assertIn(settings.NO_REPLY_EMAIL, jury_email.from_email)

        author_email = mail.outbox[0]
        self.assertIn(proposal.author.email, author_email.recipients())
        self.assertIn(settings.NO_REPLY_EMAIL, author_email.from_email)

    def test_anonymous_user_create_event_proposal(self):
        event = Event.objects.create(**self.event_data)
        self.client.logout()
        event_create_proposal_url = reverse(
            'create_event_proposal', kwargs={'slug': event.slug})
        response = self.client.post(
            event_create_proposal_url,
            self.proposal_data, follow=True
        )
        self.assertEquals(200, response.status_code)
        self.assertEquals(event_create_proposal_url,
                          response.context_data.get('redirect_field_value'))
        self.assertEquals(0, event.proposals.count())

    def test_event_create_event_proposal_with_passed_due_date(self):
        event_data = self.event_data.copy()
        event_data.update(due_date=datetime.now() - timedelta(hours=24))
        event = Event.objects.create(**event_data)
        with self.assertRaises(ValidationError):
            self.client.post(
                reverse('create_event_proposal', kwargs={'slug': event.slug}),
                self.proposal_data
            )
        self.assertEquals(0, event.proposals.count())

        response = self.client.get(
            reverse('create_event_proposal', kwargs={'slug': event.slug}))
        self.assertEqual(302, response.status_code)

    def test_export_votes_to_csv_queryset(self):
        event = Event.objects.create(**self.event_data)
        Proposal.objects.create(event=event, **self.proposal_data)
        proposals = event.get_votes_to_export()
        exported_data = [{'title': u'Python For Zombies',
                          'votes__count': 0,
                          'author__email': u'*****@*****.**',
                          'author__username': u'admin',
                          'votes__rate__sum': None,
                          'id': 1}]
        self.assertEqual(list(proposals), exported_data)

    def test_export_votes_sum_rate(self):
        event = Event.objects.create(**self.event_data)
        proposal = Proposal.objects.create(event=event, **self.proposal_data)
        user = User.objects.get(username='******')
        another_user = User.objects.get(username='******')
        Vote.objects.create(user=user, proposal=proposal, rate=2)
        Vote.objects.create(user=another_user, proposal=proposal, rate=-1)
        proposals = list(event.get_votes_to_export())
        sum_rate = sum(proposal['votes__rate__sum'] for proposal in proposals)
        self.assertEqual(1, sum_rate)

    def test_export_votes_count(self):
        event = Event.objects.create(**self.event_data)
        proposal = Proposal.objects.create(event=event, **self.proposal_data)
        user = User.objects.get(username='******')
        another_user = User.objects.get(username='******')
        Vote.objects.create(user=user, proposal=proposal, rate=1)
        Vote.objects.create(user=another_user, proposal=proposal, rate=1)
        proposals = list(event.get_votes_to_export())
        total_votes = sum(proposal['votes__count'] for proposal in proposals)
        self.assertEqual(2, total_votes)

    def test_export_event_votes_to_csv(self):
        event = Event.objects.create(**self.event_data)
        response = self.client.get(
            reverse('export_event', kwargs={'slug': event.slug}))
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response['Content-Type'], 'text/csv')

    def test_not_authorized_to_export_event_votes_to_csv(self):
        self.client.login(username='******', password='******')
        event = Event.objects.create(**self.event_data)
        response = self.client.get(
            reverse('export_event', kwargs={'slug': event.slug}))
        self.assertEqual(302, response.status_code)
Beispiel #59
0
    def test_subscribe(self):

        # Start client as admin
        broker = {
            'HOST': settings.MQTT['BROKER_TEST_HOST'],
            'PORT': 1883,
            'KEEPALIVE': 60,
            'CLEAN_SESSION': True
        }

        # Start subscribe client
        broker.update(settings.MQTT)
        broker['CLIENT_ID'] = 'test_subscribe_1'

        subscribe_client = SubscribeClient(broker, debug=True)
        self.is_connected(subscribe_client)
        self.is_subscribed(subscribe_client)

        # Start test client
        broker.update(settings.MQTT)
        client_id = 'test_subscribe_2'
        username = broker['USERNAME']
        broker['CLIENT_ID'] = client_id

        test_client = MQTTTestClient(broker, check_payload=False, debug=True)
        self.is_connected(test_client)

        # start django client
        django_client = DjangoClient()

        # login as admin
        django_client.login(username=settings.MQTT['USERNAME'],
                            password=settings.MQTT['PASSWORD'])

        # handshake ambulance and hospital
        response = django_client.post('/en/api/client/',
                                      content_type='application/json',
                                      data=json.dumps({
                                          'client_id':
                                          client_id,
                                          'status':
                                          ClientStatus.O.name,
                                          'ambulance':
                                          self.a1.id,
                                          'hospital':
                                          self.h1.id
                                      }),
                                      follow=True)
        self.assertEqual(response.status_code, 201)

        # check record
        clnt = Client.objects.get(client_id=client_id)
        self.assertEqual(clnt.status, ClientStatus.O.name)
        self.assertEqual(clnt.ambulance, self.a1)
        self.assertEqual(clnt.hospital, self.h1)

        # Modify ambulance

        # retrieve current ambulance status
        obj = Ambulance.objects.get(id=self.a1.id)
        self.assertEqual(obj.status, AmbulanceStatus.UK.name)

        # expect update once
        test_client.expect('ambulance/{}/data'.format(self.a1.id))
        self.is_subscribed(test_client)

        # publish change
        test_client.publish('user/{}/client/{}/ambulance/{}/data'.format(
            self.u1.username, client_id, self.a1.id),
                            json.dumps({
                                'status': AmbulanceStatus.OS.name,
                            }),
                            qos=0)

        # process messages
        self.loop(test_client, subscribe_client)

        # verify change
        obj = Ambulance.objects.get(id=self.a1.id)
        self.assertEqual(obj.status, AmbulanceStatus.OS.name)

        # Modify hospital

        # retrieve current hospital status
        obj = Hospital.objects.get(id=self.h1.id)
        self.assertEqual(obj.comment, 'no comments')

        # expect update once
        test_client.expect('hospital/{}/data'.format(self.h1.id))
        self.is_subscribed(test_client)

        test_client.publish('user/{}/client/{}/hospital/{}/data'.format(
            self.u1.username, client_id, self.h1.id),
                            json.dumps({
                                'comment': 'no more comments',
                            }),
                            qos=0)

        # process messages
        self.loop(test_client, subscribe_client)

        # verify change
        obj = Hospital.objects.get(id=self.h1.id)
        self.assertEqual(obj.comment, 'no more comments')

        # Modify hospital equipment

        # retrieve current equipment value
        obj = EquipmentItem.objects.get(
            equipmentholder=self.h1.equipmentholder, equipment=self.e1)
        self.assertEqual(obj.value, 'True')

        # expect update once
        test_client.expect('equipment/{}/item/{}/data'.format(
            self.h1.equipmentholder.id, self.e1.id))
        self.is_subscribed(test_client)

        test_client.publish(
            'user/{}/client/{}/equipment/{}/item/{}/data'.format(
                self.u1.username, client_id, self.h1.equipmentholder.id,
                self.e1.id),
            json.dumps({
                'value': 'False',
            }),
            qos=0)

        # process messages
        self.loop(test_client, subscribe_client)

        # verify change
        obj = EquipmentItem.objects.get(
            equipmentholder=self.h1.equipmentholder, equipment=self.e1)
        self.assertEqual(obj.value, 'False')

        # test bulk ambulance update

        # expect null client after logout
        test_client.expect('ambulance/{}/data'.format(self.a1.id))
        self.is_subscribed(test_client)

        # handshake ambulance
        response = django_client.post('/en/api/client/',
                                      content_type='application/json',
                                      data=json.dumps({
                                          'client_id':
                                          client_id,
                                          'status':
                                          ClientStatus.O.name,
                                          'ambulance':
                                          self.a2.id,
                                      }),
                                      follow=True)
        # result = JSONParser().parse(BytesIO(response.content))
        # logger.debug(result)
        self.assertEqual(response.status_code, 201)

        # check record
        clnt = Client.objects.get(client_id=client_id)
        self.assertEqual(clnt.status, ClientStatus.O.name)
        self.assertEqual(clnt.ambulance, self.a2)
        self.assertEqual(clnt.hospital, self.h1)

        # retrieve last ambulance
        obj = Ambulance.objects.get(id=self.a1.id)
        self.assertEqual(hasattr(obj, 'client'), False)

        # retrieve current ambulance status
        obj = Ambulance.objects.get(id=self.a2.id)
        self.assertEqual(obj.status, AmbulanceStatus.UK.name)

        location = {'latitude': -2., 'longitude': 7.}
        timestamp = timezone.now()
        data = [{
            'status': AmbulanceStatus.OS.name,
        }, {
            'status': AmbulanceStatus.AV.name,
            'location': location,
        }, {
            'status': AmbulanceStatus.PB.name,
            'timestamp': str(timestamp)
        }]

        # expect update once
        test_client.expect('ambulance/{}/data'.format(self.a2.id))
        self.is_subscribed(test_client)

        test_client.publish('user/{}/client/{}/ambulance/{}/data'.format(
            self.u1.username, client_id, self.a2.id),
                            json.dumps(data),
                            qos=0)

        # process messages
        self.loop(test_client, subscribe_client)

        # verify change
        obj = Ambulance.objects.get(id=self.a2.id)
        self.assertEqual(obj.status, AmbulanceStatus.PB.name)
        self.assertEqual(obj.timestamp, timestamp)
        self.assertEqual(point2str(obj.location), point2str(location))

        # Client handshake
        test_client.publish(
            'user/{}/client/{}/status'.format(username, client_id),
            ClientStatus.F.name)

        # process messages
        self.loop(test_client, subscribe_client)

        # check record
        clnt = Client.objects.get(client_id=client_id)
        self.assertEqual(clnt.status, ClientStatus.F.name)
        self.assertEqual(clnt.ambulance, None)
        self.assertEqual(clnt.hospital, None)

        # wait for disconnect
        test_client.wait()
        subscribe_client.wait()
        django_client.logout()
Beispiel #60
0
class UserViewsTestCase(TestCase):
    """Test app user views"""
    def setUp(self):
        self.user = User.objects.create_user(username='******',
                                             first_name='test',
                                             last_name='test',
                                             email='*****@*****.**',
                                             password='******')
        self.raise_awareness_group = Group.objects.create(name='Sensibiliser')
        self.raise_awareness_user = User.objects.create_user(
            username='******',
            first_name='test',
            last_name='test',
            email='*****@*****.**',
            password='******')
        self.raise_awareness_user.groups.add(self.raise_awareness_group)
        self.want_to_understand_group = Group.objects.create(name='Comprendre')
        self.want_to_understand_user = User.objects.create_user(
            username='******',
            first_name='test',
            last_name='test',
            email='*****@*****.**',
            password='******')
        self.want_to_understand_user.groups.add(self.want_to_understand_group)

        self.disorder = Disorder.objects.create(name="test",
                                                details="test",
                                                url_pattern="test")
        self.request = Request.objects.create(
            disorder=self.disorder,
            message="test",
            user=self.want_to_understand_user,
            status=0)

        self.client = Client()

    def test_login_page(self):
        """Check that login page returns status code 200"""

        response = self.client.get(reverse('app:login'))
        self.assertEqual(response.status_code, 200)

    def test_logout(self):
        """Check that logout page returns status code 200"""

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

        response = self.client.get(reverse('app:logout'))
        self.assertEqual(response.status_code, 302)

    def test_account(self):
        """Check that personnal account page returns status code 200"""

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

        response = self.client.get(reverse('app:account'))
        self.assertEqual(response.status_code, 200)

    def test_create_account(self):
        """Check that create account page returns status code 200"""

        response = self.client.get(reverse('app:create_account'))
        self.assertEqual(response.status_code, 200)

    def test_delete_account(self):
        """Check that user can delete his account"""

        self.client.login(username='******', password='******')
        users_count = len(User.objects.all())

        response = self.client.get(reverse('app:delete_account'), follow=True)

        new_users_count = len(User.objects.all())

        self.assertEqual(response.status_code, 200)
        self.assertRedirects(response, '/')
        self.assertEqual(new_users_count, users_count - 1)

    def test_access_account_raise_awareness(self):
        """Check that personnal account contains raise awareness user specific data"""

        self.client.login(username='******', password='******')
        response = self.client.get(reverse('app:account'))
        self.assertContains(
            response,
            '<a class="btn btn-primary" href="/testify/">Je veux témoigner</a>'
        )

    def test_access_account_want_to_understand(self):
        """Check that personnal account contains want to understand user specific data"""

        self.client.login(username='******', password='******')
        response = self.client.get(reverse('app:account'))
        self.assertContains(
            response,
            '<a class="btn btn-primary" href="/request/">Créer une requếte</a>'
        )

    def test_login_view(self):
        """Check that login form is validated and user is logged in"""

        response = self.client.post('/login/', {
            'username': '******',
            'password': '******'
        },
                                    follow=True)
        self.assertTrue(response.context['user'].is_active)
        self.assertRedirects(response, '/account/')

    def test_account_creation_view(self):
        """Check that account creation form is validated, new user is added to database
        and is redirected to thanks page"""

        user_count = len(User.objects.all())
        response = self.client.post('/new-user/', {
            'username': '******',
            'password': '******',
            'email': '*****@*****.**',
            'first_name': 'new',
            'last_name': 'new',
            'groups': self.raise_awareness_group
        },
                                    follow=True)
        new_user_count = len(User.objects.all())
        self.assertEqual(user_count + 1, new_user_count)
        self.assertEqual(response.status_code, 200)
        self.assertRedirects(response, '/rules/')

    def test_rules_view(self):
        """Check that thanks for creating an account
        and community rules page returns status code 200"""

        response = self.client.get(reverse('app:rules'))
        self.assertEqual(response.status_code, 200)

    def test_new_request_view(self):
        """Check that request creation form is validated,
        new request is added to database and user is redirected to his account"""

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

        response = self.client.get(reverse('app:request'))
        self.assertEqual(response.status_code, 200)

        request_count = len(Request.objects.all())
        response = self.client.post('/request/', {
            'message': 'test',
            'disorders': self.disorder
        },
                                    follow=True)
        new_request_count = len(Request.objects.all())

        self.assertEqual(
            Request.objects.latest('id').user, self.want_to_understand_user)
        self.assertEqual(request_count + 1, new_request_count)
        self.assertEqual(response.status_code, 200)
        self.assertRedirects(response, '/account/')

    def test_new_testimony_view(self):
        """Check that testimony creation form is validated,
        new testimony is added to database and user is redirected to his account"""

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

        response = self.client.get(reverse('app:testify'))
        self.assertEqual(response.status_code, 200)

        testimony_count = len(Testimony.objects.all())
        response = self.client.post('/testify/', {
            'content': 'test',
            'disorders': self.disorder
        },
                                    follow=True)
        new_testimony_count = len(Testimony.objects.all())

        self.assertEqual(
            Testimony.objects.get(pk=1).user, self.raise_awareness_user)
        self.assertEqual(testimony_count + 1, new_testimony_count)
        self.assertEqual(response.status_code, 200)
        self.assertRedirects(response, '/account/')

    def test_requests_list_page(self):
        """Check that requests list is displayed"""

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

        response = self.client.get(reverse('app:requests_list'))
        self.assertEqual(response.status_code, 200)

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

        response = self.client.get(
            reverse('app:request_info', args=[self.request.pk]))
        self.assertEqual(response.status_code, 200)

    def test_accept_request(self):
        """Check that accepting a request redirects user to account
        and that requests status is changed"""

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

        response = self.client.get(reverse('app:accept_request',
                                           args=[self.request.pk]),
                                   follow=True)

        self.request.refresh_from_db()

        self.assertEqual(response.status_code, 200)
        self.assertEqual(self.request.awareness_user,
                         self.raise_awareness_user)
        self.assertRedirects(response, '/account/')
        self.assertEqual(self.request.status, 1)

    def test_awareness_user_requests_list_page(self):
        """Check that awareness user requests list is displayed when accepted"""

        self.client.login(username='******', password='******')
        self.client.get(reverse('app:accept_request', args=[self.request.pk]),
                        follow=True)

        response = self.client.get(reverse('app:user_requests_list'))

        self.assertEqual(response.status_code, 200)

        for request in response.context["requests"]:
            self.assertEqual(request.status, 1)
            self.assertEqual(request.user, self.want_to_understand_user)
            self.assertEqual(request.awareness_user, self.raise_awareness_user)

    def test_understand_user_requests_list_page(self):
        """Check that understand user requests list is displayed when accepted"""

        self.client.login(username='******', password='******')
        self.client.get(reverse('app:accept_request', args=[self.request.pk]),
                        follow=True)

        response = self.client.get(reverse('app:user_requests_list'))

        self.assertEqual(response.status_code, 200)

        for request in response.context["requests"]:
            self.assertEqual(request.user, self.want_to_understand_user)