def test_api_can_update_watering_information(self):
"""PUT request for watering a garden plant."""
garden = Garden(id=1)
zeke = Plant(plant_type='Cherry Tomato',
image='jim_photo.jpg',
lighting='Full Sun',
water_frequency=3,
harvest_time=50,
root_depth=12,
annual="Annual")
dan = Plant(id=5,
plant_type='Cactus',
image='cactus_dan.jpg',
lighting='Full Sun',
water_frequency=7,
harvest_time=None,
root_depth=8,
annual="Annual")
db.session.add_all([zeke, dan, garden])
db.session.commit()
res_zeke = self.client().post(
'/api/v1/garden?plant_id={}&plant_name=Ezekiel'.format(zeke.id))
res_dan = self.client().post(
'/api/v1/garden?plant_id={}&plant_name=Dan'.format(dan.id))
dan_json_response = json.loads(res_dan.data)
zeke_json_response = json.loads(res_zeke.data)
self.assertEqual("Dan", dan_json_response['plant_name'])
water_res = self.client().put(
'/api/v1/garden/water?garden_plant_id={}'.format(
dan_json_response['garden_plant_id']))
self.assertEqual(water_res.status_code, 201)
last_watered = datetime.now().strftime("%a, %B %d, %Y")
next_water = (
datetime.now() +
timedelta(days=dan.water_frequency)).strftime("%a, %B %d, %Y")
water_json_response = json.loads(water_res.data)
self.assertEqual(dan_json_response['garden_plant_id'],
water_json_response['id'])
self.assertEqual(dan_json_response['plant_name'],
water_json_response['name'])
self.assertEqual(dan.plant_type, water_json_response['plant_type'])
self.assertEqual(dan.water_frequency,
water_json_response['water_frequency'])
self.assertEqual(last_watered, water_json_response['last_watered'])
self.assertEqual(next_water, water_json_response['next_water'])
self.assertNotEqual(zeke_json_response['garden_plant_id'],
water_json_response['id'])
self.assertNotEqual(zeke_json_response['plant_name'],
water_json_response['name'])
self.assertNotEqual(zeke.plant_type, water_json_response['plant_type'])
self.assertNotEqual(zeke.water_frequency,
water_json_response['water_frequency'])
def test_api_can_add_plant_to_garden_with_no_harvest_date(self):
"""Sad path test, plants can be added without harvest date."""
garden = Garden(id=1)
zeke = Plant(plant_type='Cherry Tomato',
image='jim_photo.jpg',
lighting='Full Sun',
water_frequency=3,
harvest_time=50,
root_depth=12,
annual="Annual")
dan = Plant(plant_type='Cactus',
image='cactus_dan.jpg',
lighting='Full Sun',
water_frequency=7,
harvest_time=None,
root_depth=8,
annual="Annual")
db.session.add_all([zeke, dan, garden])
db.session.commit()
res = self.client().post(
'/api/v1/garden?plant_id={}&plant_name=Cactus Dan'.format(dan.id))
self.assertEqual(res.status_code, 201)
json_response = json.loads(res.data)
self.assertIsNotNone(json_response['garden_plant_id'])
self.assertEqual(dan.id, json_response['plant_id'])
self.assertEqual(garden.id, json_response['garden_id'])
self.assertEqual("Cactus Dan", json_response['plant_name'])
self.assertEqual("N/A", json_response['harvest_date'])
self.assertNotEqual(zeke.id, json_response['plant_id'])
def registerGardenFromMap(address):
address = address
form = GardenForm()
form.address.data = address
gkey = current_app.config['GOOGLEMAPS_KEY_ALL']
if form.validate_on_submit():
response = requests.get(
'https://maps.googleapis.com/maps/api/geocode/json?address={}&key={}'
.format(form.address.data, gkey))
responseJSON = response.json()
lat = responseJSON['results'][0]['geometry']['location']['lat']
lon = responseJSON['results'][0]['geometry']['location']['lng']
garden = Garden(name=form.name.data,
address=form.address.data,
lat=lat,
lon=lon)
print(garden)
garden.users.append(current_user)
print(garden.users)
db.session.add(garden)
db.session.commit()
flash('Congratulations, you have registered a new garden!')
return redirect(url_for('main.index'))
return render_template('registerGarden.html',
title='Register Garden From Map',
form=form,
address=address)
def get_all_gardens_for_map():
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10000, type=int), 10000)
data = Garden.to_collection_dict(
Garden.query.filter(Garden.lat != None, Garden.lon != None), page,
per_page, 'api.get_all_gardens_for_map')
return jsonify(data)
def get_locations():
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10000, type=int), 10000)
data = Garden.to_collection_dict(
Garden.query.filter(Garden.lat != None,
Garden.lon != None).order_by(Garden.address), page,
per_page, 'api.get_locations')
all_gardens = Garden.query.all()
coords = []
locations = []
for garden in all_gardens:
garden_plants_objs_arr = []
if garden.lat and garden.lon:
address = garden.address
lat = garden.lat
lon = garden.lon
coord = (lat, lon)
garden_plants = garden.plants.all()
for plant in garden_plants:
plant_obj = Plant.to_dict(plant)
garden_plants_objs_arr.append(plant_obj)
garden_obj = Garden.to_dict(garden)
#handle the case where two markers would be placed in hte exact
#same spot, where only one would be visible and usable in the
#google maps once rendered
if coord in coords:
#find the index of the first garden for a given coord
index = coords.index(coord)
#use index of given coord to select the corresponding
#location_for_markers in its list and extend the plants list
locations[index]['gardens'].append(garden_obj)
locations[index]['plants'].extend(garden_plants_objs_arr)
elif coord not in coords:
coords.append(coord)
location = {
'address': address,
'latitude': lat,
'longitude': lon,
'gardens': [garden_obj],
'plants': garden_plants_objs_arr
}
locations.append(location)
return jsonify(locations)
def submit_user_garden_by_token():
id = g.current_user.id
user = User.query.get(id)
data = request.get_json() or {}
garden_name = data['gardenName']
garden_address = data['gardenAddress']
if garden_name is None:
return bad_request('No garden name found.')
if garden_address is None:
return bad_request('No address found.')
response = requests.get(
'https://maps.googleapis.com/maps/api/geocode/json?address={}&key=AIzaSyCyX0uZDxs4ekWQz-uSuhvhpABMOFf8QfI'
.format(garden_address))
responseJSON = response.json()
#This is the address validation. Cannot do any validation client-side as
#I have no knowledge of how to validate a physical address other than
#that the client-side form field(in my case React-Native/Redux) is not empty.
#So Google is tasked with validating the addresses from the mobile app submission.
#ZERO_RESULTS status means google did not find an address. So INVALID ADDRESS it is.
if responseJSON['status'] == "ZERO_RESULTS":
error = responseJSON['status']
response = jsonify({"error": error})
return bad_request("Invalid Address")
elif responseJSON['status'] == "OK":
gard = Garden.query.filter_by(name=garden_name,
address=garden_address).first()
if gard is not None:
return bad_request('Garden already exists!')
lat = responseJSON['results'][0]['geometry']['location']['lat']
lon = responseJSON['results'][0]['geometry']['location']['lng']
garden = Garden(name=garden_name,
address=garden_address,
lat=lat,
lon=lon)
garden.users.append(g.current_user)
db.session.add(garden)
db.session.commit()
#response.status_code = 201
#response = plant.to_dict()
response = jsonify(garden.to_dict())
response.headers['Location'] = url_for('api.get_current_user_gardens')
return response
else:
return bad_request('Uknown error from Google Maps API Geocode.')
def test_api_can_return_all_plants_in_garden(self):
"""GET request for returning all gardenplants."""
garden = Garden(id=1)
zeke = Plant(plant_type='Cherry Tomato',
image='jim_photo.jpg',
lighting='Full Sun',
water_frequency=3,
harvest_time=50,
root_depth=12,
annual="Annual")
dan = Plant(plant_type='Cactus',
image='cactus_dan.jpg',
lighting='Full Sun',
water_frequency=7,
harvest_time=None,
root_depth=8,
annual="Annual")
agatha = Plant(plant_type='Roma Tomato',
image='agatha_photo.jpg',
lighting='Full Sun',
water_frequency=2,
harvest_time=60,
root_depth=12,
annual="Annual")
db.session.add_all([zeke, dan, agatha, garden])
db.session.commit()
res = self.client().post(
'/api/v1/garden?plant_id={}&plant_name=Ezekiel'.format(zeke.id))
res = self.client().post(
'/api/v1/garden?plant_id={}&plant_name=Dan'.format(dan.id))
res = self.client().get('/api/v1/garden')
self.assertEqual(res.status_code, 200)
json_response = json.loads(res.data)
self.assertEqual(len(json_response), 2)
self.assertEqual(zeke.id, json_response[0]['id'])
self.assertEqual("Ezekiel", json_response[0]['plant_name'])
self.assertEqual(dan.id, json_response[1]['id'])
self.assertEqual("Dan", json_response[1]['plant_name'])
self.assertNotEqual(agatha.id, json_response[0]['id'])
self.assertNotEqual(agatha.id, json_response[1]['id'])
def test_api_can_return_garden_plant_profile_page(self):
"""GET request for gardenplant by ID (profile page)."""
garden = Garden(id=1)
adrian = Plant(id=5,
plant_type='Buckcherry',
image='adrian_photo.jpg',
lighting='Full Sun',
water_frequency=5,
harvest_time=50,
root_depth=12,
annual="Annual")
db.session.add_all([adrian, garden])
db.session.commit()
add_adrian_res = self.client().post(
'/api/v1/garden?plant_id={}&plant_name=Adrian'.format(adrian.id))
add_adrian_json = json.loads(add_adrian_res.data)
gardenplant_id = add_adrian_json['garden_plant_id']
profile_res = self.client().get(
'/api/v1/garden/plants/{}'.format(gardenplant_id))
self.assertEqual(profile_res.status_code, 200)
profile_json_response = json.loads(profile_res.data)
today = datetime.now().strftime("%a, %B %d, %Y")
harvest_date = (
datetime.now() +
timedelta(days=adrian.harvest_time)).strftime("%a, %B %d, %Y")
remaining_harvest = (
(datetime.now() + timedelta(days=adrian.harvest_time)) -
datetime.now()).days
self.assertEqual(gardenplant_id,
profile_json_response['gardenplant_id'])
self.assertEqual("Adrian", profile_json_response['plant_name'])
self.assertEqual(today, profile_json_response['date_added'])
self.assertEqual(today, profile_json_response['last_watered'])
self.assertEqual(harvest_date, profile_json_response['harvest_date'])
self.assertEqual(remaining_harvest,
profile_json_response['days_until_harvest'])
self.assertEqual(adrian.plant_type,
profile_json_response['plant_type'])
self.assertEqual(adrian.image, profile_json_response['image'])
self.assertIsNotNone(profile_json_response['days_until_next_water'])
def test_api_can_add_plant_to_garden(self):
"""POST request for adding a plant to a garden."""
garden = Garden(id=1)
zeke = Plant(plant_type='Cherry Tomato',
image='jim_photo.jpg',
lighting='Full Sun',
water_frequency=3,
harvest_time=50,
root_depth=12,
annual="Annual")
agatha = Plant(plant_type='Roma Tomato',
image='agatha_photo.jpg',
lighting='Full Sun',
water_frequency=2,
harvest_time=60,
root_depth=12,
annual="Annual")
dan = Plant(plant_type='Cactus',
image='cactus_dan.jpg',
lighting='Full Sun',
water_frequency=7,
harvest_time=None,
root_depth=8,
annual="Annual")
db.session.add_all([zeke, agatha, dan, garden])
db.session.commit()
harvest_date = (datetime.now() + timedelta(days=50))
parsed_harvest_date = harvest_date.strftime("%a, %B %d, %Y")
res = self.client().post(
'/api/v1/garden?plant_id={}&plant_name=Ezekiel'.format(zeke.id))
self.assertEqual(res.status_code, 201)
json_response = json.loads(res.data)
self.assertIsNotNone(json_response['garden_plant_id'])
self.assertEqual(zeke.id, json_response['plant_id'])
self.assertEqual(garden.id, json_response['garden_id'])
self.assertEqual("Ezekiel", json_response['plant_name'])
self.assertEqual(parsed_harvest_date, json_response['harvest_date'])
self.assertNotEqual(agatha.id, json_response['plant_id'])
self.assertNotEqual(dan.id, json_response['plant_id'])
def test_api_can_return_msg_when_no_plants_are_in_garden(self):
"""
Sad path test for returning garden plants.
Garden plants are plants in the DB that have been assigned to a garden.
Many gardens can have many plants through gardenplants. Garden
plants not only hold a foreign key of a plant and a garden, but
also specific information about planting and watering of that
particular plant in that particular garden.
"""
garden = Garden(id=1)
zeke = Plant(plant_type='Cherry Tomato',
image='jim_photo.jpg',
lighting='Full Sun',
water_frequency=3,
harvest_time=50,
root_depth=12,
annual="Annual")
dan = Plant(plant_type='Cactus',
image='cactus_dan.jpg',
lighting='Full Sun',
water_frequency=7,
harvest_time=None,
root_depth=8,
annual="Annual")
agatha = Plant(plant_type='Roma Tomato',
image='agatha_photo.jpg',
lighting='Full Sun',
water_frequency=2,
harvest_time=60,
root_depth=12,
annual="Annual")
db.session.add_all([zeke, dan, agatha, garden])
db.session.commit()
res = self.client().get('/api/v1/garden')
self.assertEqual(res.status_code, 200)
json_response = json.loads(res.data)
self.assertEqual('You have no plants in your garden',
json_response['info'])
def test_api_can_remove_a_plant_from_a_garden(self):
"""DELETE request for removing a plant from a garden."""
garden = Garden(id=1)
lincoln = Plant(plant_type='Lime',
image='lincoln_photo.jpg',
lighting='Full Sun',
water_frequency=5,
harvest_time=50,
root_depth=12,
annual="Annual")
db.session.add_all([lincoln, garden])
db.session.commit()
res = self.client().post(
'/api/v1/garden?plant_id={}&plant_name=Lincoln'.format(lincoln.id))
data_dict = json.loads(res.data)
gardenplant_id = data_dict['garden_plant_id']
res1 = self.client().get('/api/v1/garden')
self.assertEqual(res1.status_code, 200)
lincoln_in_garden_json_response = json.loads(res1.data)
self.assertEqual("Lincoln",
lincoln_in_garden_json_response[0]['plant_name'])
self.assertEqual(lincoln.id, lincoln_in_garden_json_response[0]['id'])
res2 = self.client().delete(
'/api/v1/garden/plants/{}'.format(gardenplant_id))
self.assertEqual(res2.status_code, 202)
lincoln_out_of_garden_json_response = json.loads(res2.data)
self.assertEqual("Lincoln",
lincoln_out_of_garden_json_response['plant_name'])
self.assertEqual(gardenplant_id,
lincoln_out_of_garden_json_response['gardenplant_id'])
res3 = self.client().get('/api/v1/garden')
self.assertEqual(res3.status_code, 200)
no_plants_garden_json_response = json.loads(res3.data)
self.assertEqual("You have no plants in your garden",
no_plants_garden_json_response['info'])
def test_a_garden_has_attributes(self):
"""Garden model has attributes."""
garden = Garden(id=1)
self.assertTrue(type(garden.id) is int)
for ad in addresses:
new_user = User(username=ad[1], email="{}@example.com".format(ad[1]))
new_user.set_password(ad[2])
session.add(new_user)
print(new_user.username)
address = ad[0]
if address != '':
response = requests.get(
'https://maps.googleapis.com/maps/api/geocode/json?address={}&key={}'
.format(address, gkey))
responseJSON = response.json()
lat = responseJSON['results'][0]['geometry']['location']['lat']
lon = responseJSON['results'][0]['geometry']['location']['lng']
for g in ad[3]:
new_garden = Garden(name=g[0], address=address, lat=lat, lon=lon)
new_garden.users.append(new_user)
session.add(new_garden)
print("Garden Name: ", new_garden.name, " Grower: ",
new_user.username)
for p in g[1]:
new_plant = Plant(name=p, grower=new_user, garden=new_garden)
session.add(new_plant)
print(new_plant.name)
post_body = random.choice(posts)
post = Post(body=post_body, author=new_user)
session.add(post)
session.commit()
print("-------------------------------------------------------------------")
print("-------------------------------------------------------------------")
