def test_export_event_to_ical(self):
     """Test ical export."""
     EventFactory.create(slug='test-event')
     response = self.client.get(reverse('events_icalendar_event',
                                        kwargs={'slug': 'test-event'}))
     self.assertTemplateUsed(response, 'multi_event_ical_template.ics')
     self.failUnless(response['Content-Type'].startswith('text/calendar'))

    def test_is_multiday(self):
        """Test is_multiday filter."""
        e = EventFactory.create()
        ok_(is_multiday(e.start, e.end), 'Multiday event validates to False')

        e = EventFactory.create(start=START_DT, end=self.single_day_end)
        ok_(not is_multiday(e.start, e.end),
            'Single day event validates to True')

    def test_end_date_in_the_future(self):
        owner = UserFactory.create()
        EventFactory.create(start=self.start, end=self.end + timedelta(days=2), owner=owner)

        with patch('remo.events.tasks.send_remo_mail.delay') as mail_mock:
            notify_event_owners_to_input_metrics()

        ok_(not mail_mock.called)

 def test_post_comment_on_event_unauthed(self, mock_error):
     """Test post comment on event unauthorized."""
     comment = 'This is a new comment'
     EventFactory.create(slug='test-event')
     response = self.client.post(self.event_url, {'comment': comment},
                                 follow=True)
     self.assertTemplateUsed(response, 'main.html')
     mock_error.assert_called_with(ANY, 'Permission Denied')

    def test_end_date_in_the_past(self):
        owner = UserFactory.create()
        EventFactory.create(end=now() - timedelta(days=3), owner=owner)

        with patch("remo.events.tasks.send_remo_mail") as mail_mock:
            notify_event_owners_to_input_metrics()

        ok_(not mail_mock.called)

 def test_edit_owner(self):
     """Test change event ownership."""
     owner = UserFactory.create()
     EventFactory.create(owner=owner)
     report = NGReport.objects.get(user=owner)
     new_owner = UserFactory.create()
     report.event.owner = new_owner
     report.event.save()
     report = NGReport.objects.get(pk=report.id)
     eq_(report.user, new_owner)
     eq_(report.mentor, new_owner.userprofile.mentor)

 def test_get_edit_event_admin(self, mock_success):
     """Test get event edit page with admin permissions"""
     user = UserFactory.create(groups=['Admin'])
     EventFactory.create(slug='test-event')
     self.client.login(username=user.username, password='passwd')
     response = self.client.get(self.event_edit_url, follow=True)
     eq_(response.request['PATH_INFO'], self.event_edit_url)
     ok_(not response.context['creating'])
     ok_(response.context['event_form'].editable_owner)
     eq_(response.context['event'].slug, 'test-event')
     self.assertTemplateUsed('edit_event.html')

    def test_multi_event_ical_export_past(self):
        """Test multiple past event ical export."""
        EventFactory.create_batch(2)

        # Export past events to iCal
        period = 'past'
        response = self.client.get(reverse('multiple_event_ical',
                                           kwargs={'period': period}),
                                   follow=True)
        self.failUnless(response['Content-Type'].startswith('text/calendar'))
        eq_(len(response.context['events']), 2)

    def test_similar_event_category(self):
        """Test similar events functionality"""
        kwargs = {
            'categories': self.event.categories.all()[:1],
            'country': 'CountryName',
            'start': now() + timedelta(days=10),
            'end': now() + timedelta(days=13)}

        EventFactory.create_batch(5, **kwargs)
        result = self.event.get_similar_events()
        eq_(result.count(), 5)

 def test_edit_event_page_no_delete_perms(self, mock_perm):
     """Test view edit event page without delete permissions."""
     user = UserFactory.create(groups=['Admin'])
     EventFactory.create(slug='test-event')
     mock_perm.side_effect = [True, False]
     self.client.login(username=user.username, password='passwd')
     response = self.client.get(self.event_edit_url, follow=True)
     eq_(response.request['PATH_INFO'], self.event_edit_url)
     ok_(not response.context['creating'])
     ok_(response.context['event_form'].editable_owner)
     eq_(response.context['event'].slug, 'test-event')
     ok_(not response.context['can_delete_event'])

    def test_with_existing_action_item(self):
        owner = UserFactory.create()
        EventFactory.create(start=self.start, end=self.end, owner=owner)

        with patch('remo.events.tasks.send_remo_mail.delay') as mail_mock:
            notify_event_owners_to_input_metrics()

        ok_(mail_mock.called)

        with patch('remo.events.tasks.send_remo_mail.delay') as mail_mock1:
            notify_event_owners_to_input_metrics()
        ok_(not mail_mock1.called)

 def test_subscription_management_rep(self, mock_info):
     """ Subscribe rep to event."""
     user = UserFactory.create(groups=['Rep'])
     EventFactory.create(slug='test-event')
     self.client.login(username=user.username, password='passwd')
     response = self.client.post(reverse('events_subscribe_to_event',
                                         kwargs={'slug': 'test-event'}),
                                 follow=True)
     self.assertTemplateUsed(response, 'view_event.html',
                             ('Rep user is not returned to '
                              'event page after subscribing.'))
     ok_(mock_info.called, 'messages.info() was not called')

    def test_post_event_metrics(self):
        model = ContentType.objects.get_for_model(Event)
        items = ActionItem.objects.filter(content_type=model)
        ok_(not items.exists())

        start = now() - timedelta(days=4)
        end = now() - timedelta(days=1)
        user = UserFactory.create(groups=['Rep'])
        EventFactory.create(owner=user, start=start, end=end)
        notify_event_owners_to_input_metrics()

        items = ActionItem.objects.filter(content_type=model)
        eq_(items.count(), 1)

    def test_multi_event_ical_export_search(self):
        """Test multiple past event ical export."""

        EventFactory.create(name='Test event')

        # Test 'search' query
        term = 'Test event'
        search = 'custom/search/%s' % term
        response = self.client.get(reverse('multiple_event_ical',
                                           kwargs={'period': search}),
                                   follow=True)
        self.failUnless(response['Content-Type'].startswith('text/calendar'))
        eq_(len(response.context['events']), 1)

    def test_similar_event_no_match(self):
        """Test similar events functionality"""
        categories = self.event.categories.all()
        kwargs = {
            'categories': (FunctionalArea.active_objects
                           .exclude(pk__in=categories)[:4]),
            'country': 'CountryName',
            'start': now() + timedelta(days=10),
            'end': now() + timedelta(days=13)}

        EventFactory.create_batch(5, **kwargs)
        result = self.event.get_similar_events()
        eq_(result.exists(), False)

    def test_multi_event_ical_export_future(self):
        """Test multiple past event ical export."""
        start = now() + datetime.timedelta(days=1)
        end = now() + datetime.timedelta(days=2)
        EventFactory.create_batch(2, start=start, end=end)

        # Export future events to iCal
        period = 'future'
        response = self.client.get(reverse('multiple_event_ical',
                                           kwargs={'period': period}),
                                   follow=True)
        self.failUnless(response['Content-Type'].startswith('text/calendar'))
        eq_(len(response.context['events']), 2)

    def test_with_existing_action_item(self):
        owner = UserFactory.create()
        end = now() - timedelta(days=1)
        EventFactory.create(end=end, owner=owner)

        with patch("remo.events.tasks.send_remo_mail") as mail_mock:
            notify_event_owners_to_input_metrics()

        ok_(mail_mock.called)

        with patch("remo.events.tasks.send_remo_mail") as mail_mock1:
            notify_event_owners_to_input_metrics()
        ok_(not mail_mock1.called)

    def test_unsubscribe_from_event_unsubscribed(self, mock_warning):
        """Test unsubscribe from event without subscription."""
        user = UserFactory.create(groups=['Rep'])
        EventFactory.create(slug='test-event')

        self.client.login(username=user.username, password='passwd')
        response = self.client.post(reverse('events_unsubscribe_from_event',
                                            kwargs={'slug': 'test-event'}),
                                    follow=True)
        self.assertTemplateUsed(response, 'view_event.html',
                                ('Rep user is not returned to '
                                 'event page after unsubscribing.'))
        msg = 'You are not subscribed to this event.'
        mock_warning.assert_called_with(ANY, msg)

 def test_base(self):
     event = EventFactory.create()
     url = '/api/beta/events/%s' % event.id
     request = RequestFactory().get(url)
     serializer = EventSerializer(event, context={'request': request})
     eq_(serializer.data['name'], event.name)
     ok_(serializer.data['_url'])

 def test_get_remo_url(self):
     event = EventFactory.create()
     url = '/api/beta/events/%s' % event.id
     request = RequestFactory().get(url)
     data = EventDetailedSerializer(event,
                                    context={'request': request}).data
     ok_(event.get_absolute_url() in data['remo_url'])