def install():
db.drop_all()
db.create_all()
# Sample data
from toilet.models import Category, Tag, Toilet
cat_public = Category('public')
db.session.add(cat_public)
cat_commercial = Category('commercial')
db.session.add(cat_commercial)
cat_paid = Category('paid')
db.session.add(cat_paid)
cat_code = Category('code')
db.session.add(cat_code)
tag_disabled = Tag('disabled')
db.session.add(tag_disabled)
t_sihlpost = Toilet('Sihlpost', 47.375312, 8.532493)
t_sihlpost.category = cat_commercial
t_sihlpost.tags.append(tag_disabled)
db.session.add(t_sihlpost)
db.session.commit()
return 'Installed'
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('test_foo', '*****@*****.**','bqz_qux')
self.user.save()
self.user_two = User.objects.create_user('test_bar', '*****@*****.**', 'bqz_qux')
self.user_two.save()
self.toilet = Toilet(date = datetime.datetime.now() ,
creator = self.user, name = "test_toilet")
self.toilet.save()
self.toilet_second = Toilet(date = datetime.datetime.now(),
creator = self.user, name = "test_toilet2")
self.toilet_second.save()
self.review_one_one = Review(user=self.user, date = datetime.datetime.now(),
toilet = self.toilet, content = "foo bar", rank = 5,
up_down_rank = 1)
self.review_one_one.save()
self.review_one_two = Review(user=self.user, date = datetime.datetime.now(),
toilet = self.toilet_second, content = "foo bar", rank = 5,
up_down_rank = 1)
self.review_one_two.save()
self.review_two_one = Review(user=self.user_two, date = datetime.datetime.now(),
toilet = self.toilet, content = "foo bar", rank = 5,
up_down_rank = 1)
self.review_two_one.save()
self.review_two_two = Review(user=self.user_two, date = datetime.datetime.now(),
toilet = self.toilet_second, content = "foo bar", rank = 5,
up_down_rank = 1)
self.review_two_two.save()
class putNewReviewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('test_foo', '*****@*****.**','bqz_qux')
self.user.save()
self.toilet = Toilet(date = datetime.datetime.now() ,
creator = self.user, name = "test_toilet")
self.toilet.save()
def test_put_new_review(self):
self.client.login(username=self.user.username, password = '******')
response = self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : 3, 'content' : 'This is a dumb test'})
self.assertEqual(response.status_code, 201)
review = Review.objects.get(content='This is a dumb test')
responcedict = json.loads(response.content)
self.assertEqual(review.id, responcedict[0]['pk'])
#make sure that the rating updated
self.assertEqual(Toilet.objects.get(pk=self.toilet.id).rating, 3)
def test_put_no_toilet(self):
self.client.login(username=self.user.username, password = '******')
response = self.client.post('/api/review/create/', {'toilet' : 666, 'rank' : 5, 'content' : 'This is a dumb test'})
self.assertEqual(response.status_code, 404)
@unittest.skip("Not sure what we should do in this case")
def test_missing_attributes(self):
self.client.login(username=self.user.username, password = '******')
def test_post_review_twice(self):
self.client.login(username=self.user.username, password = '******')
self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : 5, 'content' : 'This is a dumb test'})
response = self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : 5, 'content' : 'This is a dumb test'})
self.assertEqual(response.status_code, 403)
class GetReviewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('test_foo', '*****@*****.**','bqz_qux')
self.user.save()
self.user_two = User.objects.create_user('test_bar', '*****@*****.**', 'bqz_qux')
self.user_two.save()
self.toilet = Toilet(date = datetime.datetime.now() ,
creator = self.user, name = "test_toilet")
self.toilet.save()
self.toilet_second = Toilet(date = datetime.datetime.now(),
creator = self.user, name = "test_toilet2")
self.toilet_second.save()
self.review_one_one = Review(user=self.user, date = datetime.datetime.now(),
toilet = self.toilet, content = "foo bar", rank = 5,
up_down_rank = 1)
self.review_one_one.save()
self.review_one_two = Review(user=self.user, date = datetime.datetime.now(),
toilet = self.toilet_second, content = "foo bar", rank = 5,
up_down_rank = 1)
self.review_one_two.save()
self.review_two_one = Review(user=self.user_two, date = datetime.datetime.now(),
toilet = self.toilet, content = "foo bar", rank = 5,
up_down_rank = 1)
self.review_two_one.save()
self.review_two_two = Review(user=self.user_two, date = datetime.datetime.now(),
toilet = self.toilet_second, content = "foo bar", rank = 5,
up_down_rank = 1)
self.review_two_two.save()
#get all reviews by user EQ3
def test_get_review_user(self):
response = self.client.post('/api/Review/get/', { 'start' : 0, 'end' : 10, 'filters' : json.dumps({'user' : self.user.id}) })
responselist = json.loads(response.content)
#there are two reviews per user
self.assertEqual(len(responselist), 2)
for review in responselist:
self.assertEqual(review['fields']['user'], self.user.id)
#get all reviews by toilet id EQ1
def test_get_review_by_toilet(self):
response = self.client.post('/api/Review/get/', { 'start' : 0, 'end' : 10, 'filters' : json.dumps({'toilet' : self.toilet.id})})
responselist = json.loads(response.content)
#there are two reviews per toilet
self.assertEqual(len(responselist), 2)
for review in responselist:
self.assertEqual(review['fields']['toilet'], self.toilet.id)
#get all reviews by a toilet that does not exist EQ2
def test_get_review_by_non_exist_toilet(self):
response = self.client.post('/api/Review/get/', { 'start' : 0, 'end' : 10, 'filters' : json.dumps({'toilet' : 666})})
self.assertEqual(json.loads(response.content), [])
#get all reviews by user tht doesn't exists EQ4
def test_get_review_by_not_existant_user(self):
response = self.client.post('/api/Review/get/', { 'start' : 0, 'end' : 10, 'filters' : json.dumps({'user' : 666}) })
self.assertEqual(json.loads(response.content), [])
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('test_foo', '*****@*****.**','bqz_qux')
self.user.save()
self.toilet = Toilet(date = datetime.datetime.now() ,
creator = self.user, name = "test_toilet")
self.toilet.save()
def toilets():
if request.method == 'GET':
try:
lat = float(request.args.get('lat'))
lng = float(request.args.get('lng'))
except (ValueError, TypeError):
raise abort(404)
toilets = Toilet.search(lat, lng).all()
return jsonify(toilets=[t.__json__() for t in toilets])
def test_get_toilet_by_id(self):
toilet = Toilet()
toilet.name = "test"
toilet.date = datetime.datetime.now()
toilet.lat = 1
toilet.lng = 1
toilet.creator = self.user
toilet.save()
response = self.client.post('/api/Toilet/get/', { 'filters' : json.dumps({'id' : toilet.pk }), 'start' : 0, 'end' : 10})
responsedict = json.loads(response.content)
self.assertEqual(responsedict[0]['pk'], toilet.pk, "incorrect toilet return from server")
def setUp(self):
self.user = User.objects.create_user('test_flag', '*****@*****.**','bqz_qux')
self.user.save()
self.toilet = Toilet()
self.toilet.name = "New toilet"
self.toilet.date = datetime.datetime.now()
self.toilet.creator = self.user
self.toilet.save()
self.client = Client()
self.flag = Flag()
self.flag.name = "test flag"
self.flag.explanation = "this is a test flag"
self.flag.save()
def main(args):
peeFile = open(args[1])
firstLine = peeFile.next().split(',')
atrbMap = dict(enumerate(firstLine))
atrbMap = {v:k for k,v in atrbMap.items()}
#print atrbMap
peeReader = csv.reader(peeFile, dialect='excel')
restrooms = []
peepee = None
try:
peepee = User.objects.get(username='******')
except User.DoesNotExist:
peepee = User()
peepee.username = "******"
peepee.save()
for line in peeReader:
try:
line = map(lambda x : x.decode('utf-8'), line)
except UnicodeDecodeError:
continue
pooper = Toilet()
attrs = { 'name' : line[atrbMap['name']], 'lat' : line[atrbMap['lat']], 'lng' : line[atrbMap['lon']], 'numberOfReviews' : 0 , 'rating' : 0.00000, 'creator' : peepee, 'date' : datetime.datetime.now(), 'male': True, 'female': True }
pooper.setattrs(attrs)
pooper.save()
def toilet():
if request.method == 'GET':
try:
id = int(request.args.get('id'))
except (ValueError, TypeError):
raise abort(404)
t = Toilet.query.get_or_404(id)
return jsonify(toilet=t.__json__())
if request.method == 'PUT':
title = request.form.get('title')
if not title:
raise ValueError('Invalid title')
description = request.form.get('description')
address = request.form.get('address')
category_id = int(request.form.get('category'))
lat = float(request.form.get('lat'))
lng = float(request.form.get('lng'))
try:
price = int(request.form.get('price', 0))
except:
price = 0
code = request.form.get('code')
time_open = request.form.get('time_open')
time_close = request.form.get('time_close')
t = Toilet(title, lat, lng)
t.description = description
t.address = address
t.category_id = category_id
t.price = price
t.code = code
print request.form
print time_open
#t.time_open = time_open
#t.time_close = time_close
db.session.add(t)
db.session.commit()
return jsonify(success='success')
class FlagTests(TestCase):
def setUp(self):
self.user = User.objects.create_user('test_flag', '*****@*****.**','bqz_qux')
self.user.save()
self.toilet = Toilet()
self.toilet.name = "New toilet"
self.toilet.date = datetime.datetime.now()
self.toilet.creator = self.user
self.toilet.save()
self.client = Client()
self.flag = Flag()
self.flag.name = "test flag"
self.flag.explanation = "this is a test flag"
self.flag.save()
#get flags all flags, EQ3
def test_get_flags(self):
self.client.login(username=self.user.username, password ='******')
response = json.loads(self.client.post('/api/Flag/get/', {'filters' : json.dumps({})}).content)[0]
self.assertEqual(response['pk'], self.flag.pk)
#get flag by name EQ1
def test_get_flag_by_name(self):
response = json.loads(self.client.post('/api/Flag/get/', {'filters' : json.dumps({'name' : self.flag.name})}).content)[0]
self.assertEqual(response['pk'], self.flag.pk)
#EQ2
def test_get_flag_name_does_not_exist(self):
response = json.loads(self.client.post('/api/Flag/get/', {'filters' : json.dumps({'name' : 'foo bar'})}).content)
#There are no flags with name foo bar
self.assertEqual(len(response), 0)
#Get rankings of the flag
def test_get_rankings(self):
flagRanking = FlagRanking(flag=self.flag, toilet = self.toilet, up_down_vote = 0)
flagRanking.save()
response = json.loads(self.client.post('/api/FlagRanking/get/', {'filters' : json.dumps({'toilet' : self.toilet.pk}) }).content)[0]
self.assertEqual(response['fields']['up_down_vote'], 0)
self.assertEqual(response['fields']['toilet'], self.toilet.pk)
#Upvote a flag for the given toilet, EQ1
def test_upvote_flag(self):
self.client.login(username=self.user.username, password ='******')
response = json.loads(self.client.post('/api/flag/upvote/', {'toilet_pk' : self.toilet.pk, 'flag_pk' : self.flag.pk}).content)[0]
self.assertEqual(response['fields']['flag'], self.flag.pk)
self.assertEqual(response['fields']['up_down_vote'], 1)
#upvote a flag for a toilet that does not exist, EQ2
def test_upvote_flag_no_toilet(self):
self.client.login(username=self.user.username, password ='******')
response = self.client.post('/api/flag/upvote/', {'toilet_pk' : 666, 'flag_pk' : self.flag.pk})
#bad request
self.assertEqual(response.status_code, 400)
#upvote a flag that does not exist, EQ3
def test_upvote_flag_no_flag(self):
self.client.login(username=self.user.username, password ='******')
response = self.client.post('/api/flag/upvote/', {'toilet_pk' : self.toilet.pk, 'flag_pk' : 666})
#bad request
self.assertEqual(response.status_code, 400)
#Try to upvote the same flag on the same toilet twice, EQ4
def test_upvote_twice(self):
self.client.login(username=self.user.username, password ='******')
response = json.loads(self.client.post('/api/flag/upvote/', {'toilet_pk' : self.toilet.pk, 'flag_pk' : self.flag.pk}).content)[0]
self.assertEqual(response['fields']['flag'], self.flag.pk)
self.assertEqual(response['fields']['up_down_vote'], 1)
response = json.loads(self.client.post('/api/flag/upvote/', {'toilet_pk' : self.toilet.pk, 'flag_pk' : self.flag.pk}).content)[0]
self.assertEqual(response['fields']['up_down_vote'], 1)
#Try to upvote any flag while not logged in EQ5
def test_upvote_not_logged_in(self):
response = self.client.post('/api/flag/upvote/', {'toilet_pk' : self.toilet.pk, 'flag_pk' : self.flag.pk})
self.assertEqual(response.status_code, 403)
#Test downvote
def test_downvote(self):
self.client.login(username=self.user.username, password ='******')
flagRanking = FlagRanking(flag = self.flag, toilet = self.toilet, up_down_vote = 1)
flagRanking.save()
flagvote = FlagVote(user = self.user, flag = self.flag, toilet = self.toilet, vote = 1)
flagvote.save()
response = json.loads(self.client.post('/api/flag/downvote/', {'toilet_pk' : self.toilet.pk, 'flag_pk' : self.flag.pk}).content)[0]
self.assertEqual(response['fields']['flag'], self.flag.pk)
self.assertEqual(response['fields']['up_down_vote'], 0)
#get flags when there are no flags
def test_get_empty_flag_set(self):
self.flag.delete()
self.client.login(username=self.user.username, password ='******')
response = json.loads(self.client.post('/api/Flag/get/', {'filters' : json.dumps({})}).content)
self.assertEqual(len(response), 0)
def test_get_toilet_by_user_not_exists(self):
toilet = Toilet()
toilet.name = "New toilet"
toilet.date = datetime.datetime.now()
toilet.creator = self.user
toilet.save()
second_toilet = Toilet()
second_toilet.name = "Second Toilet"
second_toilet.date = datetime.datetime.now()
second_toilet.creator = self.user
second_toilet.save()
response = self.client.post('/api/Toilet/get/', { 'filters' : json.dumps({'creator' : 666}), 'start' : 0, 'end' : 10})
response_list = json.loads(response.content)
#this should probably be a 404 error
self.assertEqual(response_list, [])
def test_get_toilet_by_user(self):
toilet = Toilet()
toilet.name = "New toilet"
toilet.date = datetime.datetime.now()
toilet.creator = self.user
toilet.save()
second_toilet = Toilet()
second_toilet.name = "Second Toilet"
second_toilet.date = datetime.datetime.now()
second_toilet.creator = self.user
second_toilet.save()
response = self.client.post('/api/Toilet/get/', { 'filters' : json.dumps({'creator' : self.user.id}), 'start' : 0, 'end' : 10})
response_list = json.loads(response.content)
pk_list = [pk_elm for pk_elm in [ elm_list['pk']
for elm_list in response_list]]
self.assertEqual(len(pk_list), 2)
self.assertIn(toilet.pk, pk_list)
self.assertIn(second_toilet.pk, pk_list)
class putNewReviewTest(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('test_foo', '*****@*****.**','bqz_qux')
self.user.save()
self.toilet = Toilet(date = datetime.datetime.now() ,
creator = self.user, name = "test_toilet")
self.toilet.save()
#Add a new review with rank 3 to test toilet, EQ1
def test_put_new_review(self):
self.client.login(username=self.user.username, password = '******')
response = self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : 3, 'content' : 'This is a dumb test'})
self.assertEqual(response.status_code, 201)
review = Review.objects.get(content='This is a dumb test')
responcedict = json.loads(response.content)
self.assertEqual(review.id, responcedict[0]['pk'])
#make sure that the rating updated
self.assertEqual(Toilet.objects.get(pk=self.toilet.id).rating, 3)
#add review to a toilet that does not exists, EQ2
def test_put_no_toilet(self):
self.client.login(username=self.user.username, password = '******')
response = self.client.post('/api/review/create/', {'toilet' : 666, 'rank' : 5, 'content' : 'This is a dumb test'})
self.assertEqual(response.status_code, 400)
#add review not logged in, EQ3
def test_put_not_logged_in(self):
response = self.client.post('/api/review/create/', {'toilet' : self.toilet.pk, 'rank' : 5, 'content' : 'This is a dumb test'})
self.assertEqual(response.status_code, 403)
#add review content is to short, EQ4
def test_put_to_short(self):
self.client.login(username=self.user.username, password = '******')
response = self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : 3, 'content' : ''})
self.assertEqual(response.status_code, 400)
# add review rank is invalid, EQ5
def test_put_invalid_rank(self):
self.client.login(username=self.user.username, password = '******')
response = self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : 7, 'content' : 'This is a dumb test'})
self.assertEqual(response.status_code, 400)
#Try to post a review twice on the same toilet, EQ6
def test_post_review_twice(self):
self.client.login(username=self.user.username, password = '******')
self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : 5, 'content' : 'This is a dumb test'})
response = self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : 5, 'content' : 'This is a dumb test'})
self.assertEqual(response.status_code, 403)
#post many reviews on the same toilet (from different users)
def test_post_review_many(self):
rating_sum = 0
#generate randomw ratings for the reviews
ratings = [random.randint(1,5) for x in xrange(10)]
#for each rating, create user and add the review check for the right average on toilet ratings
for counter, rating in enumerate(ratings):
rating_sum += rating
username = '******' + str(counter)
ratingUser = User.objects.create_user(username, username + '@bar.com', 'password')
ratingUser.save()
self.client.login(username=username,password ='******')
response = self.client.post('/api/review/create/', {'toilet' : self.toilet.id , 'rank' : rating, 'content' : 'This is a dumb test with rating' + str(rating)})
avg = float(rating_sum)/ (counter + 1)
toilet = Toilet.objects.get(pk=self.toilet.pk)
self.assertEqual(round(float(toilet.rating), 6), round(avg, 6))
class UpDownVoteTest(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('test_foo', '*****@*****.**','bqz_qux')
self.user.save()
self.user_two = User.objects.create_user('test_bar', '*****@*****.**', 'bqz_qux')
self.user_two.save()
self.toilet = Toilet(date = datetime.datetime.now() ,
creator = self.user, name = "test_toilet")
self.toilet.save()
self.review_one_one = Review(user=self.user, date = datetime.datetime.now(),
toilet = self.toilet, content = "foo bar", rank = 5,
up_down_rank = 0)
self.review_one_one.save()
self.review_two_one = Review(user=self.user_two, date = datetime.datetime.now(),
toilet = self.toilet, content = "foo bar", rank = 5,
up_down_rank = 0)
self.review_two_one.save()
#Upvote review
def test_up_vote_review(self):
self.client.login(username=self.user.username, password='******')
response = json.loads(self.client.post('/api/review/upvote/', {'review_pk': self.review_one_one.pk}).content)[0]
updatedreview = Review.objects.get(pk=self.review_one_one.pk)
self.assertEqual(updatedreview.up_down_rank, 1)
#Try to upvote a review twice, only add the upvote once
def test_up_vote_twice(self):
vote = Vote(review=self.review_one_one, user = self.user_two, vote = 1)
vote.save()
self.review_one_one.up_down_rank += 1
self.review_one_one.save()
self.client.login(username=self.user_two.username, password='******')
response = json.loads(self.client.post('/api/review/upvote/', {'review_pk': self.review_one_one.pk}).content)[0]
self.assertEqual(response['fields']['up_down_rank'],1)
#Try to upvote when not logged in
def test_up_vote_not_logged_in(self):
response = self.client.post('/api/review/upvote/', {'review_pk': self.review_one_one.pk})
self.assertEqual(response.status_code, 403)
#upvote without review information
def test_up_vote_no_data(self):
self.client.login(username=self.user_two.username, password='******')
response = self.client.post('/api/review/upvote/' )
self.assertEqual(response.status_code, 400)
def test_up_vote_get(self):
self.client.login(username=self.user_two.username, password='******')
response = self.client.get('/api/review/upvote/' )
self.assertEqual(response.status_code, 415)
#upvote a review that doesn't exist
def test_up_vote_no_review(self):
self.client.login(username=self.user_two.username, password='******')
response = self.client.post('/api/review/upvote/', {'review_pk': 666})
self.assertEqual(response.status_code, 400)
#downvote a review
def test_down_vote(self):
self.client.login(username=self.user_two.username, password='******')
response = json.loads(self.client.post('/api/review/downvote/', {'review_pk' : self.review_one_one.pk}).content)[0]
self.assertEqual(response['fields']['up_down_rank'], -1)
#Test down vote and upvote on same review
def test_down_after_up_vote(self):
vote = Vote(review=self.review_one_one, user = self.user_two, vote = 1)
vote.save()
self.review_one_one.up_down_rank += 1
self.review_one_one.save()
self.client.login(username=self.user_two.username, password='******')
response = json.loads(self.client.post('/api/review/downvote/', {'review_pk': self.review_one_one.pk}).content)[0]
self.assertEqual(response['fields']['up_down_rank'],0)
