Lunching for groups.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

316 lines
10 KiB

11 years ago
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import unittest
import json
11 years ago
from luncho import server
from base import LunchoTests
from luncho.server import Group
from luncho.server import Place
class TestVote(LunchoTests):
def setUp(self):
super(TestVote, self).setUp()
self.default_user()
def tearDown(self):
super(TestVote, self).tearDown()
def _group(self):
"""Add a default group."""
group = Group(name='Test group',
owner=self.user)
server.db.session.add(group)
self.user.groups.append(group)
server.db.session.commit()
return group
def _place(self, user=None):
"""Add a default place, linked to the user."""
if not user:
user = self.user
place = Place(name='Place',
owner=user)
server.db.session.add(place)
server.db.session.commit()
return place
def test_cast_vote(self):
"""Try to cast a vote."""
group = self._group()
place = self._place()
group.places.append(place)
self.user.groups.append(group)
server.db.session.commit()
request = {'choices': [place.id]}
rv = self.post('/vote/{group_id}/'.format(group_id=group.id),
request,
token=self.user.token)
self.assertJsonOk(rv)
return
def test_cast_less_votes(self):
"""Try to cast a vote with not enough places."""
group = self._group()
place1 = self._place()
place2 = self._place()
group.places.append(place1)
group.places.append(place2)
self.user.groups.append(group)
server.db.session.commit()
request = {'choices': [place1.id]}
rv = self.post('/vote/{group_id}/'.format(group_id=group.id),
request,
token=self.user.token)
self.assertJsonError(rv, 406, 'The vote must register 2 places')
return
11 years ago
def test_already_voted(self):
"""Try to vote when the user already voted."""
group = self._group()
place = self._place()
group.places.append(place)
self.user.groups.append(group)
server.db.session.commit()
group_id = group.id
token = self.user.token
request = {'choices': [place.id]}
rv = self.post('/vote/{group_id}/'.format(group_id=group_id),
request,
token=token)
self.assertJsonOk(rv) # vote in the day
rv = self.post('/vote/{group_id}/'.format(group_id=group_id),
request,
token=token)
self.assertJsonError(rv, 406, 'User already voted today')
return
def test_already_vote_other_group(self):
"""Try to vote in two different groups in the same day."""
group1 = self._group()
place1 = self._place()
group1.places.append(place1)
self.user.groups.append(group1)
group2 = self._group()
place2 = self._place()
group2.places.append(place2)
self.user.groups.append(group2)
server.db.session.commit()
group1_id = group1.id
group2_id = group2.id
place1_id = place1.id
place2_id = place2.id
token = self.user.token
request = {'choices': [place1_id]}
rv = self.post('/vote/{group_id}/'.format(group_id=group1_id),
request,
token=token)
self.assertJsonOk(rv) # first vote for the day
request = {'choices': [place2_id]}
rv = self.post('/vote/{group_id}/'.format(group_id=group2_id),
request,
token=token)
self.assertJsonError(rv, 406, 'User already voted today')
return
def test_vote_place_not_in_group(self):
"""Vote for a place that doesn't belong to the group."""
group = self._group()
place1 = self._place()
place2 = self._place()
group.places.append(place2)
self.user.groups.append(group)
server.db.session.commit()
request = {'choices': [place1.id]}
rv = self.post('/vote/{group_id}/'.format(group_id=group.id),
request,
token=self.user.token)
self.assertJsonError(rv, 404, 'Places are not part of this group')
return
def test_vote_for_same_place_twice(self):
"""Vote for a place more than once."""
group = self._group()
place = self._place()
group.places.append(place)
self.user.groups.append(group)
server.db.session.commit()
request = {'choices': [place.id, place.id]}
rv = self.post('/vote/{group_id}/'.format(group_id=group.id),
request,
token=self.user.token)
self.assertJsonError(rv, 409, 'Places voted more than once')
return
def test_unknown_group(self):
"""Try to vote in a group that doesn't exist."""
request = {'choices': [100]}
rv = self.post('/vote/{group_id}/'.format(group_id=100),
request,
token=self.user.token)
self.assertJsonError(rv, 404, 'Group not found')
return
def test_vote_in_group_not_member(self):
"""Try to vote for a group that the user is not a member."""
group = self._group()
place = self._place()
group.places.append(place)
server.db.session.commit()
user2 = self.create_user(name='newUser',
fullname='new user',
verified=True,
create_token=True)
request = {'choices': [place.id]}
rv = self.post('/vote/{group_id}/'.format(group_id=group.id),
request,
token=user2.token)
self.assertJsonError(rv, 403, 'User is not member of this group')
return
def test_vote_place_doesnt_exist(self):
"""Vote for a place that doesnt exist."""
group = self._group()
place = self._place()
group.places.append(place)
server.db.session.commit()
request = {'choices': [place.id + 10]}
rv = self.post('/vote/{group_id}/'.format(group_id=group.id),
request,
token=self.user.token)
self.assertJsonError(rv, 404, 'Place not found')
return
def test_no_results(self):
"""Get the results when no votes were cast."""
group = self._group()
place = self._place()
group.places.append(place)
server.db.session.commit()
rv = self.get('/vote/{group_id}/'.format(group_id=group.id),
token=self.user.token)
self.assertJsonOk(rv)
data = json.loads(rv.data)
self.assertTrue('results' in data)
self.assertFalse(data['results']) # the list is empty
self.assertTrue('closed' in data)
self.assertFalse(data['closed']) # now it is a boolean
return
def test_single_vote(self):
"""Test voting in a group with a single user."""
group = self._group()
place = self._place()
group.places.append(place)
self.user.groups.append(group)
server.db.session.commit()
group_id = group.id
token = self.user.token
request = {'choices': [place.id]}
self.post('/vote/{group_id}/'.format(group_id=group_id),
request,
token=token) # we expect everything will go fine
rv = self.get('/vote/{group_id}/'.format(group_id=group_id),
token=token)
self.assertJsonOk(rv)
data = json.loads(rv.data)
self.assertTrue('results' in data)
self.assertTrue('closed' in data)
self.assertEqual(len(data['results']), 1)
self.assertTrue(data['closed'])
return
def test_incomplete_vote(self):
"""Test voting not closed due not all members voted."""
group = self._group()
place = self._place()
group.places.append(place)
self.user.groups.append(group)
user1 = self.create_user(name='newUser',
fullname='New User',
verified=True)
user1.groups.append(group)
server.db.session.commit()
group_id = group.id
token = self.user.token
request = {'choices': [place.id]}
self.post('/vote/{group_id}/'.format(group_id=group_id),
request,
token=token)
rv = self.get('/vote/{group_id}/'.format(group_id=group_id),
token=token)
self.assertJsonOk(rv)
data = json.loads(rv.data)
self.assertTrue('results' in data)
self.assertTrue('closed' in data)
self.assertEquals(len(data['results']), 1)
self.assertFalse(data['closed']) # voting shouldn't be closed yet
return
def test_get_results_unknown_group(self):
"""Try to get the results of a group that doesn't exist."""
rv = self.get('/vote/{group_id}/'.format(group_id=100),
token=self.user.token)
self.assertJsonError(rv, 404, 'Group not found')
return
def test_get_results_no_places(self):
"""Try to get the results the group have no places."""
group = self._group()
self.user.groups.append(group)
server.db.session.commit()
rv = self.get('/vote/{group_id}/'.format(group_id=group.id),
token=self.user.token)
self.assertJsonOk(rv)
data = json.loads(rv.data)
self.assertTrue('results' in data)
self.assertTrue('closed' in data)
self.assertEquals(len(data['results']), 0)
self.assertTrue(data['closed']) # voting shouldn't be closed yet
return
def test_get_results_not_member(self):
"""Try to get the results of a group when the user is not a member."""
group = self._group()
user = self.create_user(name='newUser',
create_token=True)
rv = self.get('/vote/{group_id}/'.format(group_id=group.id),
token=user.token)
self.assertJsonError(rv, 403, 'User is not member of this group')
return
11 years ago
if __name__ == '__main__':
unittest.main()