def test_multiple_surveys_for_user(self):
     user = UserFactory()
     teamtemp1 = TeamTemperatureFactory(creator=user)
     teamtemp2 = TeamTemperatureFactory(creator=user)
     self.assertNotEqual(teamtemp1.id, teamtemp2.id)
     self.assertEqual(teamtemp1.creator.id, teamtemp2.creator.id)
     self.assertEqual(user.team_temperatures.count(), 2)
 def test_multiple_responses_for_user_and_survey(self):
     user = UserFactory()
     teamtemp1 = TeamTemperatureFactory()
     teamtemp2 = TeamTemperatureFactory()
     _ = TemperatureResponseFactory(request=teamtemp1, responder=user)
     _ = TemperatureResponseFactory(request=teamtemp2, responder=user)
     self.assertEqual(user.temperature_responses.count(), 2)
     self.assertEqual(teamtemp1.temperature_responses.count(), 1)
     self.assertEqual(teamtemp2.temperature_responses.count(), 1)
示例#3
0
    def test_stats_count(self):

        team_temp = TeamTemperatureFactory()

        self.assertEqual(team_temp.stats()['count'], 0)

        TeamResponseFactory(request=team_temp)
        self.assertEqual(team_temp.stats()['count'], 1)

        TeamResponseFactory(request=team_temp)
        TeamResponseFactory(request=team_temp)

        self.assertEqual(team_temp.stats()['count'], 3)
示例#4
0
    def test_stats_word(self):

        team_temp = TeamTemperatureFactory()

        self.assertEqual(len(team_temp.stats()['words']), 0)

        TeamResponseFactory(request=team_temp, word='first')

        self.assertEqual(len(team_temp.stats()['words']), 1)

        TeamResponseFactory(request=team_temp, word='second')
        TeamResponseFactory(request=team_temp, word='third')

        self.assertEqual(len(team_temp.stats()['words']), 3)
    def test_team_temperature(self):
        teamtemp = TeamTemperatureFactory()
        self.assertTrue(len(teamtemp.id) > 0)
        self.assertIsNotNone(teamtemp.creation_date)
        self.assertIsNotNone(teamtemp.modified_date)
        self.assertEqual(teamtemp.survey_type, 'TEAMTEMP')
        self.assertRegexpMatches(str(teamtemp), "%s: %s %s " % (
            teamtemp.id, teamtemp.creator.id, re.escape(str(teamtemp.creation_date))))

        stats, query_set = teamtemp.stats()
        self.assertEqual(stats['count'], 0)
        self.assertIsNone(stats['average']['score__avg'])
        self.assertEqual(stats['words'].count(), 0)
        self.assertEqual(query_set.count(), 0)
示例#6
0
    def test_stats_average(self):

        team_temp = TeamTemperatureFactory()

        self.assertIsNone(team_temp.stats()['average']['score__avg'])

        TeamResponseFactory(request=team_temp, score=5)

        self.assertEqual(team_temp.stats()['average']['score__avg'], 5.0)

        TeamResponseFactory(request=team_temp, score=7)
        TeamResponseFactory(request=team_temp, score=6)

        self.assertEqual(team_temp.stats()['average']['score__avg'], 6.0)
示例#7
0
 def test_multiple_surveys_for_user(self):
     teamtemp = TeamTemperatureFactory()
     team1 = TeamFactory(request=teamtemp)
     team2 = TeamFactory(request=teamtemp)
     self.assertNotEqual(team1.team_name, team2.team_name)
     self.assertEqual(team1.request.id, team2.request.id)
     self.assertEqual(teamtemp.teams.count(), 2)
示例#8
0
    def test_get_temperature_view(self):

        team_temp = TeamTemperatureFactory()

        response = self.client.get(reverse('temp', args=[str(team_temp.id)]))

        self.assertTemplateUsed(response, 'form.html')
        self.assertContains(response, 'Submit your temperature')
示例#9
0
 def test_existing_survey_settings_form(self):
     survey = TeamTemperatureFactory()
     form_data = {
         'request': survey,
         'team_name': 'test',
     }
     form = AddTeamForm(data=form_data)
     self.assertTrue(form.is_valid())
 def test_multiple_response_histories(self):
     teamtemp = TeamTemperatureFactory()
     team = TeamFactory(request=teamtemp)
     _ = TeamResponseHistoryFactory(request=teamtemp,
                                    team_name=team.team_name)
     _ = TeamResponseHistoryFactory(request=teamtemp,
                                    team_name=team.team_name)
     self.assertEqual(teamtemp.team_response_histories.count(), 2)
    def setUp(self):
        self.teamtemp = TeamTemperatureFactory()
        self.team = TeamFactory(request=self.teamtemp)
        self.response = TemperatureResponseFactory(
            request=self.teamtemp, team_name=self.team.team_name)

        TeamResponseHistoryFactory(request=self.teamtemp,
                                   team_name=self.team.team_name)
        TeamResponseHistoryFactory(request=self.teamtemp, team_name='Average')
示例#12
0
    def test_results_redirects_if_not_authenticated(self):

        team_temp = TeamTemperatureFactory()

        response = self.client.get(
            reverse('result', kwargs={'pk': team_temp.id}))

        self.assertRedirects(
            response,
            'http://testserver/accounts/login/?next=/admin/{}/'.format(
                team_temp.id))
示例#13
0
    def test_score_must_be_whole_number(self):
        team_temp = TeamTemperatureFactory()

        response = self.client.post(reverse('temp', args=[str(team_temp.id)]),
                                    data={
                                        'score': 9.1,
                                        'word': 'word'
                                    })

        self.assertTemplateUsed(response, 'form.html')
        self.assertContains(response, "Enter a whole number.")
示例#14
0
    def test_post_invalid_temperature_view(self):

        team_temp = TeamTemperatureFactory()

        response = self.client.post(reverse('temp', args=[str(team_temp.id)]),
                                    data={'score': 2})

        self.assertTemplateUsed(response, 'form.html')
        # self.failIf(response.context_data['form'].is_valid())
        self.assertFormError(response, 'form', 'word',
                             'This field is required.')
示例#15
0
    def test_score_must_be_less_than_ten(self):
        team_temp = TeamTemperatureFactory()

        response = self.client.post(reverse('temp', args=[str(team_temp.id)]),
                                    data={
                                        'score': 11,
                                        'word': 'word'
                                    })

        self.assertTemplateUsed(response, 'form.html')
        self.assertContains(response,
                            "Ensure this value is less than or equal to 10.")
示例#16
0
    def test_other_users_can_not_admin_team_temp(self):

        team_temp = TeamTemperatureFactory(
            creator=User.objects.create_user('another_user'))

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

        response = self.client.get(
            reverse('result', kwargs={'pk': team_temp.id}))

        self.assertContains(response, '403 Forbidden', status_code=403)
示例#17
0
    def test_word_has_no_special_chars(self):
        team_temp = TeamTemperatureFactory()

        response = self.client.post(reverse('temp', args=[str(team_temp.id)]),
                                    data={
                                        'score': 10,
                                        'word': '*'
                                    })

        self.assertTemplateUsed(response, 'form.html')
        self.assertContains(
            response,
            "please enter a single word with alphanumeric characters only.")
 def test_existing_survey_settings_form(self):
     survey = TeamTemperatureFactory()
     form_data = {
         'id': survey.id,
         'creator': survey.creator,
         'password': survey.password,
         'archive_schedule': survey.archive_schedule,
         'survey_type': survey.survey_type,
         'default_tz': survey.default_tz,
         'max_word_count': survey.max_word_count
     }
     form = SurveySettingsForm(data=form_data)
     self.assertTrue(form.is_valid())
示例#19
0
    def test_post_valid_temperature_view(self):

        team_temp = TeamTemperatureFactory()

        response = self.client.post(reverse('temp', args=[str(team_temp.id)]),
                                    data={
                                        'score': 2,
                                        'word': 'word'
                                    })

        self.assertTemplateUsed(response, 'form.html')
        self.assertContains(
            response, "Thank you for submitting your answers. "
            "You can amend them now or later if you need to")
示例#20
0
    def test_creator_can_admin_team_temp(self):

        team_temp = TeamTemperatureFactory(creator=self.user)

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

        response = self.client.get(
            reverse('result', kwargs={'pk': team_temp.id}))

        self.assertTemplateUsed(response, 'results.html')
        self.assertContains(response, 'Submissions: 0')
        self.assertContains(response, 'Let your team know about this survey')
示例#21
0
 def setUp(self):
     self.survey = TeamTemperatureFactory()
     self.response = TemperatureResponseFactory(request=self.survey)
     self.form_data = {
         'response_id': self.response.id,
         'survey_type_title': 'test',
         'temp_question_title': 'test',
         'word_question_title': 'test',
         'team_name': self.response.team_name,
         'pretty_team_name': self.response.pretty_team_name(),
         'id': self.survey.id,
         'word': self.response.word,
         'score': self.response.score,
     }
    def test_multiple_responses_for_a_survey(self):
        teamtemp = TeamTemperatureFactory()
        response1 = TemperatureResponseFactory(request=teamtemp)
        response2 = TemperatureResponseFactory(request=teamtemp)
        response3 = TemperatureResponseFactory(request=teamtemp,
                                               word=response2.word)
        self.assertEqual(teamtemp.temperature_responses.count(), 3)

        stats, query_set = teamtemp.stats()

        self.assertEqual(stats['count'], 3)
        self.assertEqual(
            stats['average']['score__avg'],
            old_div(float(response1.score + response2.score + response3.score),
                    3))

        words = [[x['word']] * x['id__count'] for x in stats['words']]
        flat_words = sorted(itertools.chain(*words))

        self.assertEqual(
            flat_words,
            sorted([response1.word, response2.word, response3.word]))

        self.assertEqual(query_set.count(), 3)
示例#23
0
    def test_get_temperature_with_previous_response_view(
            self, mock_session_id):

        responding_user = UserFactory(id=utils.random_string(8))
        mock_session_id.return_value = responding_user.id

        team_temp = TeamTemperatureFactory()
        existing_response = TeamResponseFactory(request=team_temp,
                                                responder=responding_user)

        response = self.client.get(reverse('temp', args=[str(team_temp.id)]))

        self.assertTemplateUsed(response, 'form.html')
        self.assertContains(response, 'Submit your temperature')
        self.assertContains(response, existing_response.id)
 def test_invalid_max_word_count(self):
     with self.assertRaises(RuntimeError):
         TeamTemperatureFactory(max_word_count=0)
     with self.assertRaises(RuntimeError):
         TeamTemperatureFactory(max_word_count=11)
 def test_duplicate_teamtemp_ids(self):
     with self.assertRaises(RuntimeError):
         TeamTemperatureFactory(id='bob')
         TeamTemperatureFactory(id='bob')
 def setUp(self):
     self.teamtemp = TeamTemperatureFactory()
     self.team = TeamFactory(request=self.teamtemp)
 def test_uniq_teamtemp_ids(self):
     self.assertNotEqual(
         TeamTemperatureFactory().id,
         TeamTemperatureFactory().id)
 def test_customer_feedback(self):
     teamtemp = TeamTemperatureFactory(survey_type='CUSTOMERFEEDBACK')
     self.assertTrue(len(teamtemp.id) > 0)
     self.assertIsNotNone(teamtemp.creation_date)
     self.assertIsNotNone(teamtemp.modified_date)
     self.assertEqual(teamtemp.survey_type, 'CUSTOMERFEEDBACK')
示例#29
0
 def test_empty_add_team_form(self):
     survey = TeamTemperatureFactory()
     form = AddTeamForm(data={'request': survey})
     self.assertFalse(form.is_valid())
示例#30
0
 def test_duplicate_team_names(self):
     teamtemp = TeamTemperatureFactory()
     with self.assertRaises(RuntimeError):
         TeamFactory(team_name='bob', request=teamtemp)
         TeamFactory(team_name='bob', request=teamtemp)