def test_can_only_rate_own_company_opening(self):
     application = ApplicationFactory(opening=self.opening)
     other_user = UserFactory()
     url = reverse(
         'applications:rate', args=(application.pk, -1,)
     )
     subdomain_get(self.app, url, other_user, status=404)

    def test_promote_to_admin_different_company(self):
        admin = UserFactory(is_company_admin=True)
        user = UserFactory()

        url = reverse('accounts:promote', kwargs={'user_pk': user.id})

        subdomain_get(self.app, url, user=admin, status=404)

 def test_publish_another_company_opening(self):
     opening = OpeningFactory(
         company=self.user.company, published_date=datetime.now()
     )
     user2 = UserFactory()
     url = reverse('openings:publish_opening', args=(opening.id,))
     subdomain_get(self.app, url, user=user2, status=404)

    def test_promote_to_admin_without_being_admin(self):
        fake_admin = UserFactory()
        user = UserFactory(company=fake_admin.company)

        url = reverse('accounts:promote', kwargs={'user_pk': user.id})

        subdomain_get(self.app, url, user=fake_admin, status=404)

    def test_unpublish_opening(self):
        opening = OpeningFactory(
            company=self.user.company, published_date=datetime.now()
        )
        url = reverse('openings:publish_opening', args=(opening.id,))
        subdomain_get(self.app, url, user=self.user)

        self.assertIsNone(Opening.objects.get().published_date)

    def test_promote_to_admin_valid(self):
        admin = UserFactory(is_company_admin=True)
        user = UserFactory(company=admin.company)

        url = reverse('accounts:promote', kwargs={'user_pk': user.id})

        subdomain_get(self.app, url, user=admin)
        self.assertTrue(CustomUser.objects.get(id=user.id).is_company_admin)

    def test_get_applicant_details_different_company(self):
        application = ApplicationFactory(opening=self.opening)
        user = UserFactory(email='[email protected]')

        url = reverse(
            'applications:application_detail', args=(application.id,)
        )
        subdomain_get(self.app, url, user=user, status=404)

    def test_delete_user_valid(self):
        admin = UserFactory(is_company_admin=True)
        user = UserFactory(company=admin.company)

        url = reverse('accounts:delete', kwargs={'user_pk': user.id})

        subdomain_get(self.app, url, user=admin)
        self.assertEqual(len(CustomUser.objects.filter(id=user.id)), 0)

    def test_close_opening_valid(self):
        opening = OpeningFactory(title='DevOps', company=self.user.company)
        url = reverse('openings:publish_opening', args=(opening.id,))
        subdomain_get(self.app, url, user=self.user)

        self.assertEqual(
            Opening.objects.filter(published_date__isnull=True).count(), 0
        )

    def test_get_logout_while_logged_out(self):
        """
        GET the logout view while logged out
        Should redirect to the home page since it's not allowed to access this
        page without being logged in
        """
        subdomain_get(self.app, reverse('auth:logout'))

        self.assertTemplateUsed('accounts/login.html')

    def test_get_company(self):
        url = reverse("companies:create")

        page = subdomain_get(self.app, url, user=self.user)

        self.assertEqual(page.status_code, 200)
        self.assertIn(0, page.forms)

    def test_hire_applicant(self):
        InterviewStageFactory(tag='HIRED', company=CompanyFactory())
        hired_stage = InterviewStageFactory(tag='HIRED',
                company=self.user.company)
        EmailTemplateFactory(code="candidate_hired",
            company=self.user.company,
            subject="Congrats {{ applicant_first_name }}")
        application = ApplicationFactory(opening=self.opening)
        url = reverse(
            'applications:application_detail', args=(application.pk,)
        )
        response = subdomain_get(self.app, url, user=self.user)

        form = response.forms['transition-form']
        form['stage'] = '%s' % hired_stage.pk
        response = form.submit().follow()

        self.assertEqual(len(mail.outbox), 1)
        email, = mail.outbox
        self.assertTrue("Bilbon" in email.subject)

        application = Application.objects.get(pk=application.pk)
        self.assertEqual(application.current_stage, hired_stage)

        transition = application.stage_transitions.get()
        self.assertEqual(transition.user, self.user)
        self.assertEqual(transition.stage, hired_stage)

 def test_get_demo_login_view(self):
     response = subdomain_get(self.app, reverse('auth:login'),
         data=dict(demo=1))
     self.assertEqual(response.status_code, 200)
     form = response.forms[0]
     self.assertEqual(form['username'].value, "demo")
     self.assertEqual(form['password'].value, "demo")

    def test_discuss_an_application(self):
        application = ApplicationFactory(opening=self.opening)
        colleague = UserFactory(
            email='[email protected]', company=self.user.company
        )
        url = reverse(
            'applications:application_detail', args=(application.id,)
        )

        response = subdomain_get(self.app, url, user=self.user)

        form = response.forms['new-message-form']
        form['body'] = 'This guy is good'
        form['parent'] = ''
        response = form.submit().follow()
        self.assertContains(response, "This guy is good")
        parent_message = ApplicationMessage.objects.get()
        self.assertEqual(self.user, parent_message.user)

        form = response.forms['new-message-form']
        form['body'] = "I beg to differ"
        form['parent'] = parent_message.pk
        response = form.submit(user=colleague).follow(user=colleague)
        self.assertContains(response, "This guy is good")
        self.assertContains(response, "I beg to differ")
        new_message = ApplicationMessage.objects.get(parent=parent_message)
        self.assertEqual(colleague, new_message.user)

    def test_post_password_confirm_failure_password_mismatch(self):
        """
        POST the reset password confirmation page
        Should not change the password and shows the errors
        """
        user = UserFactory()
        uidb36 = int_to_base36(user.pk)
        token = default_token_generator.make_token(user)
        page = subdomain_get(
            self.app,
            reverse(
                'auth:confirm_reset_password',
                kwargs={
                    'uidb36': uidb36,
                    'token': token
                }
            )
        )
        form = page.forms[0]
        form['new_password1'] = 'password'
        form['new_password2'] = 'wrong'
        response = form.submit()

        user_found = CustomUser.objects.get()

        self.assertContains(response, 'The two password fields')
        self.assertFalse(user_found.check_password('password'))
        self.assertTrue(user_found.check_password('bob'))

    def test_post_password_confirm_success(self):
        """
        POST the reset password confirmation page
        Should change the password and redirects to home page
        """
        user = UserFactory()
        uidb36 = int_to_base36(user.pk)
        token = default_token_generator.make_token(user)
        page = subdomain_get(
            self.app,
            reverse(
                'auth:confirm_reset_password',
                kwargs={
                    'uidb36': uidb36,
                    'token': token
                }
            )
        )
        form = page.forms[0]
        form['new_password1'] = 'password'
        form['new_password2'] = 'password'
        response = form.submit().follow()

        user_found = CustomUser.objects.get()
        self.assertTemplateUsed(response, 'accounts/login.html')
        self.assertTrue(user_found.check_password('password'))
        self.assertFalse(user_found.check_password('bob'))

 def test_already_logged_in(self):
     """
     Testing that logged in users get redirected to the dashboard
     """
     user = UserFactory()
     response = subdomain_get(self.app, reverse('auth:login'), user=user)
     self.assertTemplateUsed(response, 'dashboard/dashboard.html')

    def test_list_stages(self):
        url = reverse('companysettings:list_stages')

        stage = InterviewStageFactory(company=self.user.company)
        page = subdomain_get(self.app, url, user=self.user)

        self.assertContains(page, stage.name)

 def test_get_invalid_activation(self):
     """
     GET the activation page with an invalid activation key
     Should raise a 404, using client instead of app since app would fail
     """
     url = reverse('accounts:activate', args=('FAKE',))
     response = subdomain_get(self.app, url, status=404)
     self.assertEqual(response.status_code, 404)

 def test_vote_application_invalid(self):
     application = ApplicationFactory(opening=self.opening)
     url = reverse(
         'applications:rate', args=(application.pk, -42,)
     )
     page = subdomain_get(self.app, url, user=self.user)
     self.assertTemplateUsed(page, 'applications/application_detail.html')
     self.assertContains(page, 'class="alert-error"')