def test_email_event_attendees(self, mock_success):
        """Send email to selected event attendees."""
        user = UserFactory.create(groups=['Rep'])
        event = EventFactory.create(slug='test-event', owner=user)
        AttendanceFactory.create_batch(3, event=event)
        self.client.login(username=user.username, password='passwd')
        reps = event.attendees.all()
        valid_data = dict()
        for rep in reps:
            field_name = '%s' % rep.id
            valid_data[field_name] = 'True'

        valid_data['subject'] = 'This is the mail subject'
        valid_data['body'] = 'This is the mail subject'
        valid_data['slug'] = 'test-event'

        url = reverse('email_attendees', kwargs={'slug': event.slug})
        response = self.client.post(url, valid_data, follow=True)
        self.assertTemplateUsed(response, 'view_event.html')

        mock_success.assert_called_with(ANY, 'Email sent successfully.')
        eq_(len(mail.outbox), 4)

        for i in range(0, len(mail.outbox)):
            eq_(len(mail.outbox[i].cc), 1)
            eq_(len(mail.outbox[i].to), 1)

    def test_attendance_list_sorting(self):
        """Test sorting of event attendance list."""
        e = EventFactory.create(start=START_DT, end=self.single_day_end)
        AttendanceFactory.create_batch(2, event=e)

        sorted_list = get_sorted_attendance_list(e)
        eq_(sorted_list[0], e.owner, 'Owner is not first.')

        copy_list = sorted_list[1:]
        sorted(copy_list, key=lambda x: '%s %s' % (x.last_name, x.first_name))

        eq_(copy_list, sorted_list[1:],
            'List is not properly sorted.')

 def test_unsubscribe_from_event_subscribed(self, mock_success):
     """Test unsubscribe from event subscribed user."""
     user = UserFactory.create(groups=['Rep'])
     event = EventFactory.create()
     AttendanceFactory.create(user=user, event=event)
     self.client.login(username=user.username, password='passwd')
     response = self.client.post(reverse('events_unsubscribe_from_event',
                                         kwargs={'slug': event.slug}),
                                 follow=True)
     self.assertTemplateUsed(response, 'view_event.html',
                             ('Rep user is not returned to '
                              'event page after unsubscribing.'))
     msg = 'You have unsubscribed from this event.'
     mock_success.assert_called_with(ANY, msg)

 def test_subscription_management_subscribed(self, mock_warning):
     """ Test subscribe already subscribed user."""
     user = UserFactory.create(groups=['Rep'])
     event = EventFactory.create()
     AttendanceFactory.create(user=user, event=event)
     self.client.login(username=user.username, password='passwd')
     response = self.client.post(reverse('events_subscribe_to_event',
                                         kwargs={'slug': event.slug}),
                                 follow=True)
     self.assertTemplateUsed(response, 'view_event.html',
                             ('Rep user is not returned to '
                              'event page after subscribing.'))
     msg = 'You are already subscribed to this event.'
     mock_warning.assert_called_with(ANY, msg)

 def test_delete_passive_event_attendance_report(self):
     """Test delete passive report after attendance delete."""
     event = EventFactory.create()
     user = UserFactory.create(groups=['Rep', 'Mentor'],
                               userprofile__initial_council=True)
     attendance = AttendanceFactory.create(event=event, user=user)
     ok_(NGReport.objects.filter(event=event, user=user).exists())
     attendance.delete()
     ok_(not NGReport.objects.filter(event=event, user=user).exists())

    def test_create_passive_event_attendance_report(self):
        """Test creating a passive report after attending an event."""
        event = EventFactory.create()
        user = UserFactory.create(groups=['Rep', 'Mentor'],
                                  userprofile__initial_council=True)
        AttendanceFactory.create(event=event, user=user)
        report = NGReport.objects.get(event=event, user=user)

        eq_(report.mentor, user.userprofile.mentor)
        eq_(report.activity.name, EVENT_ATTENDANCE_ACTIVITY)
        eq_(report.latitude, event.lat)
        eq_(report.longitude, event.lon)
        eq_(report.location, event.venue)
        eq_(report.is_passive, True)
        eq_(report.link, get_event_link(event))
        eq_(report.activity_description, event.description)
        self.assertQuerysetEqual(report.functional_areas.all(),
                                 [e.name for e in event.categories.all()],
                                 lambda x: x.name)

 def test_delete_attendance(self):
     """Test delete passive report after attendance delete."""
     activity = Activity.objects.get(name=ACTIVITY_EVENT_ATTEND)
     event = EventFactory.create()
     user = UserFactory.create(groups=['Rep', 'Mentor'],
                               userprofile__initial_council=True)
     attendance = AttendanceFactory.create(event=event, user=user)
     ok_(NGReport.objects.filter(event=event, user=user).exists())
     attendance.delete()
     query = NGReport.objects.filter(event=event, user=user,
                                     activity=activity)
     ok_(not query.exists())