def test_choicefield(self):
from app.models import Favourites, Color, MusicGenre, Sports
judy = Favourites.create(name='Judy')
self.assertEqual(judy.color, Color.green)
self.assertEqual(judy.music, MusicGenre.banjo)
self.assertEqual(judy.sport, Sports.poker)
self.assertEqual(judy.nullable, None)
judy.color = Color.blue
judy.music = MusicGenre.rock
judy.sport = Sports.mountaineering
judy.save()
judy2 = Favourites.objects.get(name='Judy')
# Check the type to make sure field's to_python is getting called
self.assertEqual(type(judy2.color), type(Color.blue))
self.assertEqual(judy2.color, Color.blue)
self.assertEqual(judy2.music, MusicGenre.rock)
self.assertEqual(judy2.sport, Sports.mountaineering)
tom = Favourites.create(name='Tom', sport=Sports.mountaineering)
self.assertEqual(Favourites.objects.filter(sport=102).count(), 2)
self.assertEqual(
Favourites.objects.filter(sport=Sports.mountaineering).count(), 2)
self.assertEqual(Favourites.objects.filter(sport__gt=10).count(), 2)
self.assertEqual(Favourites.objects.filter(color__lte=2).count(), 1)
tom.color = 1
tom.save()
tom2 = Favourites.objects.get(name='Tom')
self.assertEqual(tom2.color, Color.red)
tom_and_judy = Favourites.objects.filter(color__in=(Color.blue,
Color.red))
self.assertEqual(tom_and_judy.count(), 2)
self.assertEqual(set(obj.name for obj in tom_and_judy),
set(['Judy', 'Tom']))
self.assertEqual(tom2.get_sport_display(), 'Mountaineering')
def favourite_car(car_id):
if request.method == 'POST':
userid = g.current_user['userid']
fav = Favourites(car_id, userid)
db.session.add(fav)
db.session.commit()
return jsonify(message="Car added as Favourite!")
def test_form_with_choicefields(self):
from app.models import Favourites, Color, MusicGenre, Sports
from app.forms import FavouritesForm
empty_form = FavouritesForm()
self.assertFalse(empty_form.is_valid())
self.assertEqual(empty_form._bound_value('color'), Color.green.id)
self.assertEqual(empty_form._bound_value('music'), None)
self.assertEqual(empty_form._bound_value('sport'), None)
self.assertEqual(empty_form._bound_value('name'), None)
self.assertEqual(empty_form._bound_value('nullable'), None)
empty_form_data = FavouritesForm(data={
'color': 1,
'music': 2,
'sport': 3,
'name': 'Richard'
})
self.assertTrue(empty_form_data.is_valid())
self.assertEqual(empty_form_data._bound_value('color'), Color.red.id)
self.assertEqual(empty_form_data._bound_value('music'),
MusicGenre.country.id)
self.assertEqual(empty_form_data._bound_value('sport'),
Sports.baseball.id)
self.assertEqual(empty_form_data._bound_value('name'), 'Richard')
self.assertEqual(empty_form_data._bound_value('nullable'), None)
judy = Favourites.create(name='Judy')
judy_form = FavouritesForm(instance=judy)
self.assertFalse(judy_form.is_valid()) # because it's not bound
self.assertEqual(judy_form._bound_value('color'), Color.green.id)
self.assertEqual(judy_form._bound_value('music'), MusicGenre.banjo.id)
self.assertEqual(judy_form._bound_value('sport'), Sports.poker.id)
self.assertEqual(judy_form._bound_value('name'), 'Judy')
self.assertEqual(judy_form._bound_value('nullable'), None)
data_for_form = dict(judy_form.initial)
data_for_form.update({'nullable': Color.red})
judy_form_data = FavouritesForm(instance=judy, data=data_for_form)
self.assertTrue(judy_form_data.is_valid())
self.assertEqual(judy_form_data._bound_value('color'), Color.green.id)
self.assertEqual(judy_form_data._bound_value('music'),
MusicGenre.banjo.id)
self.assertEqual(judy_form_data._bound_value('sport'), Sports.poker.id)
self.assertEqual(judy_form_data._bound_value('name'), 'Judy')
self.assertEqual(judy_form_data._bound_value('nullable'), Color.red.id)
invalid_data_for_form = dict(judy_form.initial)
invalid_data_for_form.update({
'color': -1,
'music': '',
'sport': None,
'nullable': ''
})
judy_form_invalid_data = FavouritesForm(instance=judy,
data=invalid_data_for_form)
self.assertFalse(judy_form_invalid_data.is_valid())
self.assertEqual(set(judy_form_invalid_data.errors.keys()),
set(['color', 'music', 'sport']))
self.assertTrue(
'not a valid choice' in judy_form_invalid_data.errors['color'][0])
self.assertTrue(
'cannot be null' in judy_form_invalid_data.errors['music'][0])
self.assertTrue(
'cannot be null' in judy_form_invalid_data.errors['sport'][0])
def add_fav(car_id):
message = [{"errors": "Invalid request"}]
if request.method == 'POST':
fav = Favourites(car_id, g.current_user['id'])
db.session.add(fav)
db.session.commit()
message = [{"message": "Car Successfully Favourited", "car_id": car_id}]
return jsonify(message)
def favorites(car_id):
user_id = current_user.id
query = db.session.query(Favourites).filter(
Favourites.car_id == car_id, Favourites.user_id == user_id).all()
if not query and request.method == 'POST':
fav_car = Favourites(user_id, car_id)
db.session.add(fav_car)
db.session.commit()
data = {'message': "Car Successfully Favourited", "car_id": car_id}
return jsonify(data=data)
errors = {'errors': ['Car is already a favourite!']}
return jsonify(errors=errors)
def carFav(car_id):
if request.method == 'POST':
num = Favourites.query.filter_by(car_id=car_id).filter_by(
user_id=current_user.id).all()
l = len(num)
if l > 0:
info = {"message": "Car Already Favourited", "car_id": car_id}
return jsonify(info=info)
fav = Favourites(car_id, current_user.id)
db.session.add(fav)
db.session.commit()
info = {"message": "Car Successfully Favourited", "car_id": fav.car_id}
return jsonify(info=info)
info = {"message": "Car Failed to be Favourited"}
return jsonify(info=info)
def favourite(car_id):
json_favourite = request.get_json(silent=True)
cid = json_favourite.get("car_id")
uid = json_favourite.get("user_id")
isFav = Favourites.query.filter(Favourites.car_id == cid).filter(
Favourites.user_id == uid).first()
if isFav == None:
favourite = Favourites(car_id=cid, user_id=uid)
db.session.add(favourite)
db.session.commit()
data = {'message': 'Car Successfully Favourited', 'id': car_id}
return jsonify(data=data)
return jsonify({"warning": "Car is already added to Favourites"})
def add_favourite(car_id):
if current_user.is_authenticated:
if request.method == 'GET':
#Save information to database.
user_id = current_user.get_id()
favourite = Favourites(car_id=car_id, user_id=user_id)
db.session.add(favourite)
db.session.commit()
#Format and return response message.
cr = Cars.query.filter_by(id=car_id).first()
user = Users.query.filter_by(id=user_id).first()
message = {
'message':
'{0} Successfully Added {1} - {2} To Favourites.'.format(
user.username, cr.make, cr.model)
}
return jsonify(message=message)