예제 #1
0
class TestEventResource(JWTResourceTestCase):
    def setUp(self):
        super(TestEventResource, self).setUp()
        self.user = FacebookCustomUser.objects.\
            create_user(username='******', password='******',
                        first_name='Andrii', last_name='Soldatenko')
        UserLocation.objects.create(user=self.user,
                                    position=[-87.627696, 41.880745])
        self.event = Event.objects.\
            create(starts_on='2055-06-13T05:15:22.792659',
                   ends_on='2055-06-14T05:15:22.792659',
                   name="Play piano", location=[7000, 22965.83])
        self.membership = Membership.objects.\
            create(user=self.user, event=self.event,
                   is_organizer=True, rsvp='yes')
        assign_perm('view_event', self.user, self.event)
        self.detail_url = '/api/v1/event/{0}/'.format(self.event.pk)
        self.post_data = {
            'user': '******'.format(self.user.pk),
            'events': '/api/v1/event/{0}/'.format(self.event.pk),
        }
        self.neo = NeoFourJ()
        self.neo.graph.delete_all()

    def test_get_list_unauthorized(self):
        self.assertHttpUnauthorized(
            self.api_client.get('/api/v1/event/', format='json'))

    def test_get_list_json(self):
        resp = self.api_client.get('/api/v1/event/{}/'.format(self.event.id),
                                   format='json',
                                   authentication=self.get_credentials())
        self.assertValidJSONResponse(resp)

        self.maxDiff = None
        json = self.deserialize(resp)
        self.assertEqual(json['hosted_by'], 'Andrii Soldatenko')
        self.assertEqual(json['name'], 'Play piano')
        self.assertEqual(json['location'], u'7000,22965.83')
        self.assertEqual(json['total_attendees'], 1)

    def test_hosted_by(self):
        resp = self.api_client.get('/api/v1/event/',
                                   format='json',
                                   authentication=self.get_credentials())
        self.assertEqual(
            self.deserialize(resp)['objects'][0]['hosted_by'],
            'Andrii Soldatenko')

    def test_cumulative_match_score(self):
        user1 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        user2 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        UserLocation.objects.create(user=user1,
                                    position=[-87.627696, 41.880745])
        UserLocation.objects.create(user=user2,
                                    position=[-87.627696, 41.880745])
        self.subject = Subject.objects.create(description='Python')
        self.subject2 = Subject.objects.create(description='Ruby')
        self.subject3 = Subject.objects.create(description='Erlang')

        Goal.objects.create(user=self.user, goal=self.subject)
        Offer.objects.create(user=self.user, offer=self.subject2)
        Goal.objects.create(user=user1, goal=self.subject2)
        Offer.objects.create(user=user1, offer=self.subject)
        Goal.objects.create(user=user2, goal=self.subject2)

        Friend.objects.create(friend1=user1, friend2=self.user, status=1)
        Friend.objects.create(friend1=user2, friend2=self.user, status=1)
        event = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                     ends_on='2055-06-14T05:15:22.792659',
                                     name="Play piano",
                                     location=[7000, 22965.83])
        Membership.objects.create(user=self.user,
                                  event=event,
                                  is_organizer=True)
        Membership.objects.create(user=user1, event=event, rsvp='yes')
        Membership.objects.create(user=user2, event=event, rsvp='yes')
        detail_url = '/api/v1/event/{0}/'.format(event.pk)
        assign_perm('view_event', self.user, event)
        resp = self.api_client.get(detail_url,
                                   format='json',
                                   authentication=self.get_credentials())
        # TODO: because of need read test celery tasks
        self.assertEqual(self.deserialize(resp)['cumulative_match_score'], 0)

    def test_create_simple_event(self):
        post_data = {
            'description': 'Test description',
            'ends_on': str(now() + timedelta(days=2)),
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'repeat': u'W',
            'starts_on': str(now() + timedelta(days=1))
        }
        self.assertHttpCreated(
            self.api_client.post('/api/v1/event/',
                                 format='json',
                                 data=post_data,
                                 authentication=self.get_credentials()))

    def test_create_public_event(self):
        post_data = {
            'description': 'Test description',
            'ends_on': str(now() + timedelta(days=2)),
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'repeat': u'W',
            'access_level': 'public',
            'starts_on': str(now() + timedelta(days=1))
        }
        self.assertHttpCreated(
            self.api_client.post('/api/v1/event/',
                                 format='json',
                                 data=post_data,
                                 authentication=self.get_credentials()))

    def test_update_simple_event(self):
        user1 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        user2 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        Membership.objects.create(user=user1, event=self.event, rsvp='yes')
        Membership.objects.create(user=user2, event=self.event, rsvp='yes')
        self.assertEqual(
            Event.objects.filter(membership__user=self.user,
                                 name='Play piano')[0].name, 'Play piano')
        original_data = self.deserialize(
            self.api_client.get(self.detail_url,
                                format='json',
                                authentication=self.get_credentials()))
        new_data = original_data.copy()
        new_data['name'] = 'learn erlang'

        self.api_client.put(self.detail_url,
                            format='json',
                            data=new_data,
                            authentication=self.get_credentials())
        self.assertEqual(
            Event.objects.filter(membership__user=self.user,
                                 name='learn erlang')[0].name, 'learn erlang')

    def test_update_public_event_to_private(self):
        user1 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        post_data = {
            'description': 'Test description',
            'ends_on': str(now() + timedelta(days=2)),
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'repeat': u'W',
            'access_level': 'public',
            'starts_on': str(now() + timedelta(days=1))
        }
        resp = self.api_client.post('/api/v1/event/',
                                    format='json',
                                    data=post_data,
                                    authentication=self.get_credentials())
        original_event = self.deserialize(resp)
        detail_url = '/api/v1/event/{}/'.format(original_event['id'])

        new_data = original_event.copy()
        new_data['access_level'] = 'private'
        self.api_client.put(self.detail_url,
                            format='json',
                            data=new_data,
                            authentication=self.get_credentials())
        e = Event.objects.get(pk=int(original_event['id']))
        self.assertEqual(user1.has_perm('view_event', e), False)

    @skip
    def test_update_private_event_to_public(self):
        user1 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        post_data = {
            'description': 'Test description',
            'ends_on': str(now() + timedelta(days=2)),
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'repeat': u'W',
            'access_level': 'private',
            'starts_on': str(now() + timedelta(days=1))
        }
        resp = self.api_client.post('/api/v1/event/',
                                    format='json',
                                    data=post_data,
                                    authentication=self.get_credentials())
        original_event = self.deserialize(resp)
        detail_url = '/api/v1/event/{}/'.format(original_event['id'])

        new_data = original_event.copy()
        new_data['access_level'] = 'PUBLIC'
        resp = self.api_client.put(self.detail_url,
                                   format='json',
                                   data=new_data,
                                   authentication=self.get_credentials())
        e = Event.objects.get(pk=int(original_event['id']))
        self.assertEqual(user1.has_perm('view_event', e), True)

    def test_total_number_of_event_attendees(self):
        user1 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        user2 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        user3 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        user4 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')

        Membership.objects.create(user=user1, event=self.event, rsvp='yes')
        Membership.objects.create(user=user2, event=self.event, rsvp='no')
        Membership.objects.create(user=user3, event=self.event, rsvp='maybe')
        Membership.objects.create(user=user4, event=self.event, rsvp=None)

        resp = self.api_client.get('/api/v1/event/{}/'.format(self.event.id),
                                   format='json',
                                   authentication=self.get_credentials())
        json = self.deserialize(resp)
        self.assertEqual(json['total_attendees'], 2)

    def test_update_if_ends_on_in_past(self):
        event = Event.objects.create(starts_on=now() - timedelta(days=10),
                                     ends_on=now() - timedelta(days=9),
                                     name="Play piano",
                                     location=[7000, 22965.83])
        Membership.objects.create(user=self.user,
                                  event=event,
                                  is_organizer=True)

        detail_url = '/api/v1/event/{0}/'.format(event.pk)
        assign_perm('view_event', self.user, event)
        original_data = self.deserialize(
            self.api_client.get(detail_url,
                                format='json',
                                authentication=self.get_credentials()))
        new_data = original_data.copy()
        new_data['name'] = 'learn erlang'
        new_data['ends_on'] = now() + timedelta(days=2)
        new_data['starts_on'] = now() + timedelta(days=1)

        resp = self.api_client.patch(detail_url,
                                     format='json',
                                     data=new_data,
                                     authentication=self.get_credentials())
        self.assertEqual(
            self.deserialize(resp), {
                u'error':
                u'Users cannot edit events which have an end '
                u'date that occurred in the past.'
            })

    def test_create_event_which_ends_in_the_past(self):
        post_data = {
            'description': 'Test description',
            'ends_on': now() - timedelta(days=7),
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'repeat': u'W',
            'starts_on': now() - timedelta(days=9)
        }
        resp = self.api_client.post('/api/v1/event/',
                                    format='json',
                                    data=post_data,
                                    authentication=self.get_credentials())
        self.assertEqual(
            self.deserialize(resp), {
                u'event': {
                    u'error': [
                        'The event end date and time '
                        'must occur in the future.'
                    ]
                }
            })

    def test_create_event_which_starts_eq_ends(self):
        post_data = {
            'description': 'Test description',
            'ends_on': now() + timedelta(days=1),
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'repeat': u'W',
            'starts_on': now() + timedelta(days=1)
        }
        resp = self.api_client.post('/api/v1/event/',
                                    format='json',
                                    data=post_data,
                                    authentication=self.get_credentials())
        self.assertEqual(
            self.deserialize(resp), {
                u'event': {
                    u'error': [
                        u'The event end date and time '
                        u'must occur after the start '
                        u'date and time.'
                    ]
                }
            })

    def test_delete_simple_event(self):
        self.assertEqual(Event.objects.count(), 1)
        self.assertHttpAccepted(
            self.api_client.delete(self.detail_url,
                                   format='json',
                                   authentication=self.get_credentials()))
        self.assertEqual(Event.objects.count(), 0)

    def test_delete_event(self):
        event = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                     ends_on='2055-06-14T05:15:22.792659',
                                     name="Play piano",
                                     location=[7000, 22965.83])
        Membership.objects.create(user=self.user,
                                  event=event,
                                  is_organizer=True,
                                  rsvp='yes')

        detail_url = '/api/v1/event/{0}/'.format(event.pk)
        self.assertEqual(Event.objects.count(), 2)
        assign_perm('view_event', self.user, event)
        self.assertHttpAccepted(
            self.api_client.delete(detail_url,
                                   format='json',
                                   authentication=self.get_credentials()))
        self.assertEqual(Event.objects.count(), 1)

    def test_friend_attendees_count(self):
        user1 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        user2 = FacebookCustomUser.objects.create_user(username='******',
                                                       password='******')
        self.neo.create_friendship(user1, self.user)
        self.neo.create_friendship(self.user, user2)
        event = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                     ends_on='2055-06-14T05:15:22.792659',
                                     name="Play piano",
                                     location=[7000, 22965.83])
        Membership.objects.create(user=self.user,
                                  event=event,
                                  is_organizer=True)
        Membership.objects.create(user=user1, event=event, rsvp='yes')
        Membership.objects.create(user=user2, event=event, rsvp='yes')
        detail_url = '/api/v1/event/{0}/'.format(event.pk)
        assign_perm('view_event', self.user, event)
        resp = self.api_client.get(detail_url,
                                   format='json',
                                   authentication=self.get_credentials())
        self.assertEqual(self.deserialize(resp)['friend_attendees_count'], 2)

    def test_post_event_photo(self):
        new_file = SimpleUploadedFile('new_file.txt', 'Hello world!')

        post_data = {
            'description': 'Test description',
            'ends_on': '2055-06-15T05:15:22.792659',
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'repeat': u'W',
            'starts_on': '2055-06-13T05:15:22.792659',
            'event_photo': new_file
        }

        resp = self.api_client.client.post(
            '/api/v1/event/',
            data=post_data,
            format='json',
            HTTP_AUTHORIZATION=self.get_credentials())

        self.assertNotEqual(self.deserialize(resp)['event_photo'], '')

    def test_get_private_event(self):
        event = Event.objects.create(name="Public Event",
                                     location=[7000, 22965.83],
                                     access_level='public',
                                     starts_on=now(),
                                     ends_on=now() + timedelta(days=10))
        Membership.objects.create(user=self.user, event=event)
        assign_perm('view_event', self.user, event)

        resp = self.api_client.get('/api/v1/event/{}/'.format(event.id),
                                   format='json',
                                   authentication=self.get_credentials())
        self.assertValidJSONResponse(resp)

        json = self.deserialize(resp)
        self.assertEqual(json['name'], 'Public Event')

    @skip
    def test_post_private_event_with_access_user_list(self):
        user = FacebookCustomUser.objects. \
            create_user(username='******', password='******',
                        first_name='Mary', last_name='Mal')

        user2 = FacebookCustomUser.objects. \
            create_user(username='******', password='******',
                        first_name='Mary Kay', last_name='Peterson')
        post_data = {
            'description': 'Test description',
            'ends_on': str(now() + timedelta(days=2)),
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'access_level': 'private',
            'access_user_list': ','.join(map(str, [user.id, user2.id])),
            'repeat': u'W',
            'starts_on': str(now() + timedelta(days=1))
        }
        resp = self.api_client.post('/api/v1/event/',
                                    format='json',
                                    data=post_data,
                                    authentication=self.get_credentials())
        self.assertHttpCreated(resp)
        event = self.deserialize(resp)
        e = Event.objects.get(pk=int(event['id']))
        self.assertEqual(user.has_perm('view_event', e), True)
        self.assertEqual(user2.has_perm('view_event', e), True)

    def test_post_public_event(self):
        user = FacebookCustomUser.objects. \
            create_user(username='******', password='******',
                        first_name='Mary', last_name='Mal')
        UserLocation.objects.create(user=user,
                                    position=[-87.627696, 41.880745])
        post_data = {
            'description': 'Test description',
            'ends_on': str(now() + timedelta(days=2)),
            'location': u'7000,22965.83',
            'name': u'Play piano',
            'access_level': 'public',
            'access_user_list': str(user.id),
            'repeat': u'W',
            'starts_on': str(now() + timedelta(days=1))
        }
        resp = self.api_client.post('/api/v1/event/',
                                    format='json',
                                    data=post_data,
                                    authentication=self.get_credentials())
        self.assertHttpCreated(resp)
        event = self.deserialize(resp)

        resp = self.api_client.get(
            '/api/v1/event/{}/'.format(event['id']),
            format='json',
            authentication=self.get_credentials(user=user))
        self.assertEqual(
            self.deserialize(resp)['access_user_list'], str(user.id))
예제 #2
0
class TestMatchQuerySet(BaseTestCase, JWTResourceTestCase):
    fixtures = ['initial_data.json']

    def setUp(self):
        super(TestMatchQuerySet, self).setUp()
        haystack.connections.reload('default')
        Goal.objects.all().delete()
        Offer.objects.all().delete()
        Subject.objects.all().delete()
        FacebookCustomUser.objects.all().delete()
        photo = SimpleUploadedFile(name='test_image.jpg', content='test')
        self.user = FacebookCustomUser.objects.\
            create_user(username='******', facebook_id=1234567,
                        first_name='Andrii', password='******', gender='m',
                        date_of_birth=date(1989, 5, 20), image=photo)
        self.user1 = FacebookCustomUser.objects.\
            create_user(username='******', facebook_id=12345671,
                        first_name='Sasa', gender='m', password='******',
                        date_of_birth=date(1979, 1, 9), image=photo)
        self.user2 = FacebookCustomUser.objects. \
            create_user(username='******', facebook_id=12345672,
                        first_name='Ira', gender='f', password='******',
                        date_of_birth=date(1969, 1, 9), image=photo)
        self.user3 = FacebookCustomUser.objects. \
            create_user(username='******', facebook_id=12345676,
                        first_name='Natali', gender='f', password='******',
                        date_of_birth=date(1959, 1, 9), image=photo)
        self.user4 = FacebookCustomUser.objects. \
            create_user(username='******', facebook_id=12345675,
                        first_name='Tati', gender='f', password='******',
                        date_of_birth=date(1949, 1, 9), image=photo)
        self.user5 = FacebookCustomUser.objects. \
            create_user(username='******', facebook_id=12345674,
                        first_name='Ken', gender='m', password='******',
                        date_of_birth=date(1939, 1, 9), image=photo)

        user_location = UserLocation.objects.create(
            user=self.user, position=[-87.627696, 41.880745])
        user_location1 = UserLocation.objects.create(
            user=self.user1, position=[60.627675, 21.881925])
        user_location2 = UserLocation.objects.create(
            user=self.user2, position=[-87.6281729688, 41.881849562])
        user_location3 = UserLocation.objects.create(
            user=self.user5, position=[-87.62839, 41.88206])
        user_location4 = UserLocation.objects.create(
            user=self.user4, position=[-87.6269801114, 41.8814058757])
        user_location5 = UserLocation.objects.create(user=self.user3,
                                                     position=[38.53, 77.02])

        self.subject = Subject.objects.create(description='learning django')
        self.subject2 = Subject.objects.create(description='learn python')
        self.subject3 = Subject.objects.create(description='teach erlang')
        self.subject4 = Subject.objects.create(description='teach javascript')

        self.subject5 = Subject.objects.create(description='teach django')
        self.subject6 = Subject.objects.create(description='teach python')
        self.subject7 = Subject.objects.create(description='learn erlang')
        self.subject8 = Subject.objects.create(description='learn javascript')
        self.subject9 = Subject.objects.\
            create(description='django under the hood')
        self.subject10 = Subject.objects.\
            create(description='learn kiteboarding and foxes')
        self.subject11 = Subject.objects.\
            create(description='like a kiteboard and fox')
        self.subject12 = Subject.objects. \
            create(description='baby')
        self.subject13 = Subject.objects. \
            create(description='child')
        self.subject14 = Subject.objects. \
            create(description='hire a dog sitter')
        self.subject16 = Subject.objects. \
            create(description='play with dogs')
        self.subject15 = Subject.objects. \
            create(description='learn to code django python')

        self.i_subject = InterestSubject.objects.\
            create(description='teach django')
        self.i_subject1 = InterestSubject.objects. \
            create(description='learn django')
        self.i_subject2 = InterestSubject.objects. \
            create(description='teach python')
        self.i_subject3 = InterestSubject.objects. \
            create(description='learn python')
        self.i_subject4 = InterestSubject.objects. \
            create(description='kiteboarding')
        StopWords.objects.create(word='learn')
        StopWords.objects.create(word=u'and')
        StopWords.objects.create(word=u'teach')
        StopWords.objects.create(word=u'to')
        clear_index.Command().handle(interactive=False)
        rebuild_index.Command().handle(interactive=False)
        self.neo = NeoFourJ()
        self.neo.graph.delete_all()

    def tearDown(self):
        pass
        # haystack.connections['default'].get_backend().clear()

    def test_simple_match_goals(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine.\
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['highlight']['goals'],
                         [u'teach <em>django</em>'])

    def test_simple_match_offers(self):
        Offer.objects.create(user=self.user, offer=self.subject2)
        Offer.objects.create(user=self.user1, offer=self.subject6)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['highlight']['offers'],
                         [u'teach <em>python</em>'])

    def test_simple_match_interests(self):
        Interest.objects.create(user=self.user, interest=self.i_subject)
        Interest.objects.create(user=self.user1, interest=self.i_subject1)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['highlight']['interests'],
                         [u'learn <em>django</em>'])

    def test_simple_match_likes(self):
        FacebookLike.objects.create(user_id=self.user.id,
                                    facebook_id=123456,
                                    name='learn python')
        fb_like = FacebookLike.objects.create(user_id=self.user1.id,
                                              facebook_id=123456,
                                              name='learn python')
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['_source']['likes_fb_ids'],
                         [unicode(fb_like.facebook_id)])

    def test_simple_match_two_goals_to_two_offers(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user, goal=self.subject2)
        Offer.objects.create(user=self.user1, offer=self.subject5)
        Offer.objects.create(user=self.user1, offer=self.subject6)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['highlight']['offers'],
                         [u'teach <em>django</em>', u'teach <em>python</em>'])

    def test_match_goals_to_offers(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user, goal=self.subject2)
        Offer.objects.create(user=self.user1, offer=self.subject5)
        Offer.objects.create(user=self.user1, offer=self.subject3)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['_source']['offers'],
                         [u'teach django', u'teach erlang'])
        self.assertEqual(match_users[0]['highlight']['offers'],
                         [u'teach <em>django</em>'])

    def test_simple_match_query_set(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Offer.objects.create(user=self.user1, offer=self.subject5)
        update_index.Command().handle(interactive=False)
        users = MatchQuerySet.all(self.user.id)
        self.assertEqual(len(users), 1)
        self.assertEqual(users[0].first_name, 'Sasa')

    def test_highlight_simple_match_goal_query_set(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        update_index.Command().handle(interactive=False)
        users = MatchQuerySet.all(self.user.id)
        self.assertEqual(users[0].goals, [{u'teach django': 1}])

    def test_highlight_simple_match_offer_query_set(self):
        Offer.objects.create(user=self.user, offer=self.subject)
        Offer.objects.create(user=self.user1, offer=self.subject5)
        update_index.Command().handle(interactive=False)
        users = MatchQuerySet.all(self.user.id)
        self.assertEqual(users[0].offers, [{u'teach django': 1}])

    def test_highlight_simple_match_interest_query_set(self):
        Interest.objects.create(user=self.user, interest=self.i_subject)
        Interest.objects.create(user=self.user1, interest=self.i_subject1)
        update_index.Command().handle(interactive=False)
        users = MatchQuerySet.all(self.user.id)
        self.assertEqual(users[0].interests, [{u'learn django': 1}])

    def test_simple_match_score_goals(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user, goal=self.subject2)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user1, goal=self.subject6)
        Goal.objects.create(user=self.user1, goal=self.subject7)
        update_index.Command().handle(interactive=False)
        users = MatchQuerySet.all(self.user.id)
        self.assertEqual(users[0].score, 2)

    def test_simple_match_score_offers(self):
        Offer.objects.create(user=self.user, offer=self.subject)
        Offer.objects.create(user=self.user, offer=self.subject2)
        Offer.objects.create(user=self.user1, offer=self.subject5)
        Offer.objects.create(user=self.user1, offer=self.subject6)
        Offer.objects.create(user=self.user1, offer=self.subject7)
        update_index.Command().handle(interactive=False)
        users = MatchQuerySet.all(self.user.id)
        self.assertEqual(users[0].score, 2)

    def test_simple_match_goals_with_stop_words(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject9)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['highlight']['goals'],
                         [u'<em>django</em> under the hood'])

    def test_simple_match_goals_with_stop_words2(self):
        Goal.objects.create(user=self.user, goal=self.subject14)
        Goal.objects.create(user=self.user1, goal=self.subject16)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['highlight']['goals'],
                         [u'play with <em>dogs</em>'])

    def test_simple_match_goals_with_root_forms_of_word(self):
        Goal.objects.create(user=self.user, goal=self.subject11)
        Goal.objects.create(user=self.user1, goal=self.subject10)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['highlight']['goals'],
                         [u'learn <em>kiteboarding</em> and <em>foxes</em>'])

    def test_simple_match_between(self):
        Goal.objects.create(user=self.user, goal=self.subject11)
        Goal.objects.create(user=self.user1, goal=self.subject10)
        Goal.objects.create(user=self.user2, goal=self.subject10)
        Goal.objects.create(user=self.user3, goal=self.subject10)
        update_index.Command().handle(interactive=False)
        users = MatchQuerySet.between(self.user.id, self.user1.id)
        self.assertEqual(len(users), 1)
        self.assertEqual(users[0].score, 1)

    def test_simple_match_synonyms(self):
        Goal.objects.create(user=self.user, goal=self.subject12)
        Goal.objects.create(user=self.user1, goal=self.subject12)
        update_index.Command().handle(interactive=False)
        match_users = ElasticSearchMatchEngine. \
            elastic_objects.match(user_id=self.user.id)
        self.assertEqual(
            match_users[0]['_id'],
            u'members.facebookcustomuseractive.%s' % self.user1.id)
        self.assertEqual(match_users[0]['highlight']['goals'],
                         [u'<em>baby</em>'])

    def test_simple_top_interests(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject15)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].top_interests[0], {
            u'coding': 0,
            u'django': 1,
            u'python': 0
        })

    def test_top_interests(self):
        Goal.objects.create(user=self.user, goal=self.subject12)
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user, goal=self.subject2)
        Offer.objects.create(user=self.user, offer=self.subject3)
        Goal.objects.create(user=self.user1, goal=self.subject13)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user1, goal=self.subject6)
        Offer.objects.create(user=self.user1, offer=self.subject7)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].top_interests, [{
            u'child': 0,
            u'django': 1,
            u'erlang': 1,
            u'python': 1
        }])

    def test_simple_top_interests_less_than_3(self):
        Goal.objects.create(user=self.user, goal=self.subject11)
        Goal.objects.create(user=self.user1, goal=self.subject10)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].top_interests[0], {
            u'kiteboarding': 1,
            u'foxes': 0
        })

    def test_simple_top_interests_less_than_1(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject10)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id)
        self.assertEqual(len(match_users), 0)

    def test_filter_gender_male(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user3, goal=self.subject5)
        FilterState.objects.create(user=self.user, gender='m', distance=16516)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].first_name, 'Sasa')
        self.assertEqual(match_users[0].gender, 'm')

    def test_filter_gender_female(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user4, goal=self.subject5)
        FilterState.objects.create(user=self.user, gender='f', max_age=99)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].first_name, 'Tati')
        self.assertEqual(match_users[0].gender, 'f')

    def test_filter_gender_all(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user3, goal=self.subject5)
        Goal.objects.create(user=self.user4, goal=self.subject5)
        FilterState.objects.create(user=self.user,
                                   gender='f,m',
                                   max_age=99,
                                   distance=16516)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 3)

    def test_filter_age(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user3, goal=self.subject5)
        Goal.objects.create(user=self.user4, goal=self.subject5)
        FilterState.objects.create(user=self.user, min_age=60, max_age=67)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].first_name, 'Tati')
        self.assertEqual(match_users[0].age, 67)

    def test_filter_keywords(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user1, goal=self.subject2)
        Goal.objects.create(user=self.user3, goal=self.subject5)
        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   keyword='python',
                                   distance=16516)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].first_name, 'Sasa')
        self.assertEqual(match_users[0].goals, [{
            u'learn python': 0,
            u'teach django': 1
        }])

    def test_filter_two_keywords(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user1, goal=self.subject2)
        Goal.objects.create(user=self.user3, goal=self.subject5)
        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   keyword='python,ruby',
                                   distance=16516)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].first_name, 'Sasa')
        self.assertEqual(match_users[0].goals, [{
            u'learn python': 0,
            u'teach django': 1
        }])

    def test_filter_with_different_word_form_of_keywords(self):
        """
        Searching Crowd for "hiking" yields no results
        (but search for "hike" does) - ICE-1311
        """
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject)
        Goal.objects.create(user=self.user1,
                            goal=Subject.objects.create(description='hiking'))

        Goal.objects.create(user=self.user2, goal=self.subject)

        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   keyword='hike',
                                   distance=16516)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].first_name, 'Sasa')
        self.assertEqual(match_users[0].goals, [{
            u'learning django': 1,
            u'hiking': 0
        }])

    def test_filter_with_different_word_form_of_keywords2(self):
        """
        Searching Crowd for "hiking" yields no results
        (but search for "hike" does) - ICE-1311
        """
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject)
        Goal.objects.create(user=self.user1,
                            goal=Subject.objects.create(description='hike'))

        Goal.objects.create(user=self.user2, goal=self.subject)

        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   keyword='hiking',
                                   distance=16516)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].first_name, 'Sasa')
        self.assertEqual(match_users[0].goals, [{
            u'learning django': 1,
            u'hike': 0
        }])

    def test_filter_keywords_negative_case(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user1, goal=self.subject2)
        Goal.objects.create(user=self.user3, goal=self.subject5)
        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   keyword='ruby')
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 0)

    def test_filter_distance(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user1, goal=self.subject2)
        Goal.objects.create(user=self.user3, goal=self.subject5)
        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   distance=1)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 0)

    def test_exclude_friends(self):
        Goal.objects.create(user=self.user, goal=self.subject)
        Goal.objects.create(user=self.user1, goal=self.subject5)
        Goal.objects.create(user=self.user3, goal=self.subject5)
        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   distance=10000)
        self.neo.create_friendship(self.user, self.user3)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id)
        self.assertEqual(len(match_users), 1)
        self.assertEqual(match_users[0].first_name, 'Sasa')

    def test_order_mutual_friends(self):
        Goal.objects.get_or_create(user=self.user, goal=self.subject)
        Goal.objects.get_or_create(user=self.user1, goal=self.subject5)
        Goal.objects.get_or_create(user=self.user2, goal=self.subject5)
        Goal.objects.get_or_create(user=self.user3, goal=self.subject5)
        Goal.objects.get_or_create(user=self.user4, goal=self.subject5)
        Goal.objects.get_or_create(user=self.user5, goal=self.subject5)
        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   distance=16000,
                                   order_criteria='mutual_friends')
        self.neo.create_friendship(self.user, self.user1)
        self.neo.create_friendship(self.user, self.user3)
        self.neo.create_friendship(self.user5, self.user1)
        self.neo.create_friendship(self.user5, self.user3)
        self.neo.create_friendship(self.user4, self.user1)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
        self.assertEqual(len(match_users), 3)
        resp = self.api_client.get('/api/v1/matchfeed/',
                                   authentication=self.get_credentials(),
                                   format='json')
        self.assertValidJSONResponse(resp)
        data = self.deserialize(resp)['objects']
        self.assertEqual(data[0]['friends_score'], 2)
        self.assertEqual(data[1]['friends_score'], 1)
        self.assertEqual(data[2]['friends_score'], 0)

    def test_simple_phrase(self):
        s = Subject.objects.create(description='foreign language')
        Goal.objects.get_or_create(user=self.user, goal=s)
        Goal.objects.get_or_create(user=self.user1, goal=s)
        update_index.Command().handle(interactive=False)
        match_users = MatchQuerySet.all(self.user.id, is_filter=True)
예제 #3
0
class TestMatchEvents(BaseTestCase, JWTResourceTestCase):
    def setUp(self):
        super(TestMatchEvents, self).setUp()
        haystack.connections.reload('default')
        FacebookCustomUser.objects.all().delete()
        self.user = FacebookCustomUser.objects. \
            create_user(username='******', facebook_id=1234567,
                        first_name='Andrii', password='******', gender='m',
                        date_of_birth=date(1989, 5, 20))
        self.user1 = FacebookCustomUser.objects. \
            create_user(username='******', facebook_id=12345671,
                        first_name='Sasa', gender='m', password='******',
                        date_of_birth=date(1979, 1, 9))
        user_location = UserLocation.objects.create(
            user=self.user, position=[-87.627696, 41.880745])
        user_location1 = UserLocation.objects.create(
            user=self.user1, position=[-87.627696, 41.880745])
        self.subject = Subject.objects.create(description='learning django')
        self.subject2 = Subject.objects.create(description='learn python')
        clear_index.Command().handle(interactive=False)
        rebuild_index.Command().handle(interactive=False)
        self.neo = NeoFourJ()
        self.neo.graph.delete_all()

    def get_credentials(self):
        pass

    def test_my_events(self):
        self.event = Event.objects. \
            create(starts_on='2055-06-13T05:15:22.792659',
                   ends_on='2055-06-14T05:15:22.792659',
                   name="Play piano", location=[7000, 22965.83])
        self.event1 = Event.objects. \
            create(starts_on='2055-06-13T05:15:22.792659',
                   ends_on='2055-06-14T05:15:22.792659',
                   name="python meetup", location=[7000, 22965.83])
        self.membership = Membership.objects. \
            create(user=self.user, event=self.event,
                   is_organizer=True, rsvp='yes')
        self.membership = Membership.objects. \
            create(user=self.user1, event=self.event1,
                   is_organizer=True, rsvp='yes')
        assign_perm('view_event', self.user, self.event)
        update_index.Command().handle(interactive=False)
        events = MatchQuerySet.all_event(self.user.id, feed='my')
        self.assertEqual(len(events), 1)
        self.assertEqual(events[0].name, 'Play piano')

    def test_all_events(self):
        self.event = Event.objects. \
            create(starts_on='2055-06-13T05:15:22.792659',
                   ends_on='2055-06-14T05:15:22.792659',
                   name="Play piano", location=[7000, 22965.83])
        self.event1 = Event.objects. \
            create(starts_on='2055-06-13T05:15:22.792659',
                   ends_on='2055-06-14T05:15:22.792659',
                   name="python meetup", location=[7000, 22965.83])
        self.membership = Membership.objects. \
            create(user=self.user, event=self.event,
                   is_organizer=True, rsvp='yes')
        self.membership = Membership.objects. \
            create(user=self.user1, event=self.event1,
                   is_organizer=True, rsvp='yes')
        assign_perm('view_event', self.user, self.event)
        update_index.Command().handle(interactive=False)
        events = MatchQuerySet.all_event(self.user.id, feed='all')
        self.assertEqual(len(events), 2)
        self.assertEqual(
            sorted(events, key=lambda x: x.name)[0].name, 'Play piano')

    def test_connections_events(self):
        self.event = Event.objects. \
            create(starts_on='2055-06-13T05:15:22.792659',
                   ends_on='2055-06-14T05:15:22.792659',
                   name="Play piano", location=[7000, 22965.83])
        self.event1 = Event.objects. \
            create(starts_on='2055-06-13T05:15:22.792659',
                   ends_on='2055-06-14T05:15:22.792659',
                   name="python meetup", location=[7000, 22965.83])
        self.membership = Membership.objects. \
            create(user=self.user, event=self.event,
                   is_organizer=True, rsvp='yes')
        self.membership = Membership.objects. \
            create(user=self.user1, event=self.event1,
                   is_organizer=True, rsvp='yes')
        self.neo.create_friendship(self.user, self.user1)
        assign_perm('view_event', self.user, self.event)
        update_index.Command().handle(interactive=False)
        events = MatchQuerySet.all_event(self.user.id, feed='connections')
        self.assertEqual(len(events), 1)
        self.assertEqual(events[0].name, 'python meetup')

    def test_filter_by_distance_my_events(self):
        e = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                 ends_on='2055-06-14T05:15:22.792659',
                                 name="Play piano",
                                 location=[7000, 22965.83])

        e1 = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                  ends_on='2055-06-14T05:15:22.792659',
                                  name="python meetup",
                                  location=[700, 22965.83])

        Membership.objects.create(user=self.user,
                                  event=e,
                                  is_organizer=True,
                                  rsvp='yes')
        Membership.objects.create(user=self.user,
                                  event=e1,
                                  is_organizer=True,
                                  rsvp='yes')
        assign_perm('view_event', self.user, e)
        assign_perm('view_event', self.user, e1)
        update_index.Command().handle(interactive=False)
        events = MatchQuerySet.all_event(self.user.id, feed='my')
        self.assertEqual(len(events), 2)
        self.assertEqual(events[0].distance[0], 4904)

    def test_filter_by_keywords_my_events(self):
        e = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                 ends_on='2055-06-14T05:15:22.792659',
                                 name="Play piano",
                                 location=[7000, 22965.83])

        e1 = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                  ends_on='2055-06-14T05:15:22.792659',
                                  name="python meetup",
                                  location=[700, 22965.83])

        Membership.objects.create(user=self.user,
                                  event=e,
                                  is_organizer=True,
                                  rsvp='yes')
        Membership.objects.create(user=self.user,
                                  event=e1,
                                  is_organizer=True,
                                  rsvp='yes')
        assign_perm('view_event', self.user, e)
        assign_perm('view_event', self.user, e1)
        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   keyword='python',
                                   distance=16516)
        update_index.Command().handle(interactive=False)
        events = MatchQuerySet.all_event(self.user.id,
                                         feed='my',
                                         is_filter=True)
        self.assertEqual(len(events), 1)
        self.assertEqual(events[0].name, 'python meetup')

    def test_filter_by_recommended_event_score_my_events(self):
        e = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                 ends_on='2055-06-14T05:15:22.792659',
                                 description='PyCon is a conference for the '
                                 'Python community, organized by '
                                 'members of the Python community '
                                 'PyCon is for Python enthusiasts '
                                 'of all experience levels, from '
                                 'new users to core developers.',
                                 name="Python Con",
                                 location=[7000, 22965.83])

        e1 = Event.objects.create(starts_on='2055-06-13T05:15:22.792659',
                                  ends_on='2055-06-14T05:15:22.792659',
                                  name="python meetup",
                                  location=[700, 22965.83])

        Goal.objects.get_or_create(user=self.user, goal=self.subject)
        Goal.objects.get_or_create(user=self.user, goal=self.subject2)
        Membership.objects.create(user=self.user,
                                  event=e,
                                  is_organizer=True,
                                  rsvp='yes')
        Membership.objects.create(user=self.user,
                                  event=e1,
                                  is_organizer=True,
                                  rsvp='yes')
        assign_perm('view_event', self.user, e)
        assign_perm('view_event', self.user, e1)
        FilterState.objects.create(user=self.user,
                                   min_age=18,
                                   max_age=99,
                                   keyword='python',
                                   order_criteria='event_score',
                                   distance=16516)
        update_index.Command().handle(interactive=False)
        events = MatchQuerySet.all_event(self.user.id,
                                         feed='my',
                                         is_filter=True)
        self.assertEqual(len(events), 2)
        self.assertEqual(events[0].name, 'python meetup')
        self.assertEqual(events[0].recommended_event_score, 1)
        self.assertEqual(events[1].recommended_event_score, 4)
예제 #4
0
class TestInboxLastResource(JWTResourceTestCase):
    def setUp(self):
        super(TestInboxLastResource, self).setUp()
        self.maxDiff = None
        self.user = FacebookCustomUser.objects.create_user(username='******',
                                                           password='******',
                                                           facebook_id=12345)
        self.user1 = FacebookCustomUser.objects.create_user(username='******',
                                                            password='******',
                                                            facebook_id=12346)
        self.user2 = FacebookCustomUser.objects.create_user(username='******',
                                                            password='******',
                                                            facebook_id=12347)
        self.user3 = FacebookCustomUser.objects.create_user(username='******',
                                                            password='******',
                                                            facebook_id=12348)
        self.neo = NeoFourJ()
        self.neo.create_friendship(self.user, self.user1)
        self.neo.create_friendship(self.user, self.user3)
        self.neo.create_friendship(self.user1, self.user2)
        for x in range(10):
            pm_write(self.user1, self.user, 'test %s' % x)
        for x in range(10):
            pm_write(self.user2, self.user, 'test %s' % x)
        for x in range(10):
            pm_write(self.user3, self.user, 'test %s' % x)

        self.resource_url = '/api/v1/inbox/last/'

    def test_get_list_unauthorized(self):
        self.assertHttpUnauthorized(
            self.api_client.get(self.resource_url, format='json'))

    def test_get_list_message_user(self):
        resp = self.api_client.get(self.resource_url,
                                   format='json',
                                   authentication=self.get_credentials())
        expected_last_message = {
            'facebook_id': u'12346',
            'first_name': u'',
            'friend_id': u'{}'.format(self.user1.id),
            'image': None,
            'last_message_body': u'',
            'last_name': u'',
            'read_at': None,
            'recipient_id': u'/api/v1/auth/user/{}/'.format(self.user.id),
            'sender_id': u'/api/v1/auth/user/{}/'.format(self.user1.id),
            'unread_counter': 10
        }
        actual_response = self.deserialize(resp)['objects'][1]
        # Remove sent_at
        del actual_response['sent_at']
        del actual_response['resource_uri']
        del actual_response['id']
        self.assertEqual(actual_response, expected_last_message)

    def test_get_list_message_user1(self):
        resp = self.api_client.get(
            self.resource_url,
            format='json',
            authentication=self.get_credentials(user=self.user1))
        expected_last_message = {
            u'facebook_id': u'12345',
            u'first_name': u'',
            u'friend_id': u'{}'.format(self.user.id),
            u'image': None,
            u'last_message_body': None,
            u'last_name': u'',
            u'read_at': None,
            u'recipient_id': u'/api/v1/auth/user/{}/'.format(self.user.id),
            u'sender_id': u'/api/v1/auth/user/{}/'.format(self.user1.id),
            u'unread_counter': 0
        }
        actual_response = self.deserialize(resp)['objects'][0]
        del actual_response['resource_uri']
        del actual_response['id']
        del actual_response['sent_at']
        self.assertEqual(actual_response, expected_last_message)

    def test_get_list_no_messages(self):
        resp = self.api_client.get(
            self.resource_url,
            format='json',
            authentication=self.get_credentials(user=self.user2))
        actual_response = self.deserialize(resp)['objects']
        self.assertEqual(len(actual_response), 0)

    def test_sorted(self):
        resp = self.api_client.get(self.resource_url,
                                   format='json',
                                   authentication=self.get_credentials())
        actual_response = self.deserialize(resp)['objects']
        self.assertEqual(actual_response[0]['sender_id'],
                         u'/api/v1/auth/user/{}/'.format(self.user3.id))
        self.assertEqual(actual_response[1]['sender_id'],
                         u'/api/v1/auth/user/{}/'.format(self.user1.id))