def setUp(self):
"""Stuff to do before every test."""
self.client = app.test_client()
app.config['TESTING'] = True
# Connect to test database (uncomment when testing database)
connect_to_db(app, "postgresql:///testdb")
# Create tables and add sample data (uncomment when testing database)
db.create_all()
example_data()
with self.client as c:
with c.session_transaction() as sess:
sess['RSVP'] = True
def tearDown(self):
"""Do at end of every test."""
# (uncomment when testing database)
db.session.close()
db.drop_all()
def test_games(self):
result = self.client.get("/games")
self.assertIn("Clue", result.data)
def index():
model.connect_to_db() # connect to database, using code from model
# do I need the post id?
# what exactly is happening here?
posts = model.get_all_posts()
return render_template("index.html", all_posts=posts)
def view_user(username):
model.connect_to_db()
user_id = model.get_user_by_name(username)
posts = model.get_wall_posts(user_id[0])
return render_template("wall.html", posts = posts,
logged_in = session["user_id"],
username = username)
def post_to_wall(username):
model.connect_to_db()
user_id = model.get_userid_by_name(username)
post_input = request.form.get("content")
author_id = session['username']
model.create_wall_post(user_id, author_id, post_input)
return redirect(url_for("view_user", username=username))
def setUp(self):
"""Stuff to do before every test."""
# Get the Flask test client
self.client = app.test_client()
# Mock session
# Connect to temporary database
connect_to_db(app, "sqlite:///")
# Create tables and add sample data
db.create_all()
sample_data()
def _mock_grab_image_dimensions(filename):
return (920, 764)
self._old_grab_image_dimensions = server.grab_image_dimensions
server.grab_image_dimensions = _mock_grab_image_dimensions
def _mock_generate_thumb(filename, crop_thumb):
return None
self._old_generate_thumb = server.generate_thumb
server.generate_thumb = _mock_generate_thumb
def setUp(self):
"""Do before every test."""
# Get the Flask test client
self.client = app.test_client()
# Show Flask errors that happen during tests
app.config['TESTING'] = True
# Connect to test database
connect_to_db(app, "postgresql:///testdb")
db.create_all()
# Make mocks
def _mock_get_yelp_search_results(term, location, category_filter, limit):
"""Mocks search results of Yelp API call for one restaurant."""
search_results = {"businesses": [{"rating": 4.5, "rating_img_url": "https://s3-media2.fl.yelpcdn.com/assets/2/www/img/99493c12711e/ico/stars/v1/stars_4_half.png", "review_count": 547, "name": "Saru Sushi Bar", "rating_img_url_small": "https://s3-media2.fl.yelpcdn.com/assets/2/www/img/a5221e66bc70/ico/stars/v1/stars_small_4_half.png", "url": "http://www.yelp.com/biz/saru-sushi-bar-san-francisco?utm_campaign=yelp_api&utm_medium=api_v2_search&utm_source=6XuCRI2pZ5pIvcWc9SI3Yg", "image_url": "https://s3-media2.fl.yelpcdn.com/bphoto/5-ugy01zjSvudVsfdhmCsA/ms.jpg", "display_phone": "+1-415-400-4510", "id": "saru-sushi-bar-san-francisco", "location": {"city": "San Francisco", "postal_code": "94114", "country_code": "US", "address": ["3856 24th St"], "coordinate": {"latitude": 37.751706, "longitude": -122.4288283}, "state_code": "CA"}}]}
return search_results
def _mock_is_open_now_true(keyword, location):
"""Mocks Google Places API call to return True for current open status."""
return True
self._old_is_open_now = process_results.is_open_now
process_results.is_open_now = _mock_is_open_now_true
self.old_get_yelp_search_results = server.yelp.search_query
server.yelp.search_query = _mock_get_yelp_search_results
def setUp(self):
# Get the Flask test client
self.client = app.test_client()
# Show Flask errors that happen during tests
app.config['TESTING'] = True
# Connect to test database
connect_to_db(app, "postgresql:///testdb")
# Create tables from model
db.create_all()
# Import different types of data from seed file
seed.load_users()
seed.load_groups()
seed.load_usergroups()
seed.load_patterns()
seed.load_invites()
# Reset auto incrementing primary keys to start after seed data
seed.set_val_user_id()
seed.set_val_group_id()
seed.set_val_usergroup_id()
seed.set_val_pattern_id()
seed.set_val_invite_id()
def setUp(self):
print "(setUp ran)"
self.client = server.app.test_client() # Sets up fake test browser
server.app.config['TESTING'] = True # Makes a 500 error in a route raise an error in a test
connect_to_db(app, "postgresql:///testdb") # Connect to temporary DB
db.create_all()
def setUp(cls):
"""Do once before all tests in this class"""
# Get the Flask test client
cls.client = app.test_client()
# Show Flask errors that happen during tests
app.config['TESTING'] = True
# Connect to test database
connect_to_db(app, "postgresql:///testdb")
# Create tables from model
db.create_all()
# Import different types of data from seed file
seed.load_users()
seed.load_groups()
seed.load_usergroups()
seed.load_patterns()
seed.load_invites()
seed.set_val_user_id()
seed.set_val_group_id()
seed.set_val_usergroup_id()
seed.set_val_pattern_id()
seed.set_val_invite_id()
with cls.client as c:
with c.session_transaction() as sess:
sess['user_id'] = 1
c.set_cookie('localhost', 'MYCOOKIE', 'cookie_value')
def setUp(self):
"""Do at the beginning of every test"""
# Get the Flask test client
self.client = app.test_client()
# Show Flask errors that happen during tests
app.config['TESTING'] = True
# Connect to test database
connect_to_db(app, "postgresql:///testdb")
# Create tables from model
db.create_all()
# Import different types of data from seed file
seed.load_users()
seed.load_groups()
seed.load_usergroups()
seed.load_patterns()
seed.load_invites()
# Reset auto incrementing primary keys to start after seed data
seed.set_val_user_id()
seed.set_val_group_id()
seed.set_val_usergroup_id()
seed.set_val_pattern_id()
seed.set_val_invite_id()
with self.client as c:
with c.session_transaction() as sess:
sess['user_id'] = 1
c.set_cookie('localhost', 'MYCOOKIE', 'cookie_value')
def setUp(self):
"""Setup to do before every test."""
# Get the Flask test client
self.client = app.test_client()
# secret key to allow sessions to be used
app.config['SECRET_KEY'] = 'sekrit!'
# Show Flask errors that happen during tests
app.config['TESTING'] = True
# Connect to test database
connect_to_db(app, db_uri="postgresql:///testdb")
# Create tables and add sample data
db.create_all()
# create db records for yarns, users, baskets, basket_yarns,
# projects, and patterns
create_example_data()
# create db records for preferences and user_preferences
load_preferences("test_data/preference_data.txt")
load_user_preferences("test_data/user_preference_data.txt")
with self.client as c:
with c.session_transaction() as session:
session['username'] = '******'
def create_account():
username = request.form.get("username")
password1 = request.form.get("password")
password2 = request.form.get("password_verify")
print "top of create account", username,password1,password2
if len(username) < 1:
flash("username must be longer than 0 characters")
return redirect(url_for("register"))
if password1 != password2:
flash ("passwords must match, try again")
return redirect(url_for("register"))
else:
print "I'm connecting to the database cause the passwords matched!"
model.connect_to_db()
if model.user_exists(username):
flash ("That user already exists")
else:
model.create_new_account(username, password1)
flash ("Welcome")
model.CONN.close()
return redirect(url_for("index"))
def setUp(self):
"""Setup to do before every test."""
# Get the Flask test client
self.client = app.test_client()
app.jinja_env.undefined = StrictUndefined
app.jinja_env.filters['prettify_preference'] = prettify_preference
# Show Flask errors that happen during tests
app.config['TESTING'] = True
# Connect to test database
connect_to_db(app, db_uri="postgresql:///testdb")
# start with empty db
db.drop_all()
# Create tables and add sample data
db.create_all()
# create db records for yarns, users, baskets, basket_yarns,
# projects, and patterns
create_example_data()
# create db records for preferences and user_preferences
load_preferences("test_data/preference_data.txt")
load_user_preferences("test_data/user_preference_data.txt")
load_group_events("test_data/group-events.csv")
def view_user(username):
model.connect_to_db()
owner_id = model.get_user_by_name(username)
wallposts = model.get_wall_posts(owner_id)
html = render_template("wall.html", wallposts = wallposts)
# print "print in_view user fucntion"
return html
def register():
model.connect_to_db()
if session.get("user_id"):
return redirect(url_for('view_user', username=session.get("username")))
else:
return render_template("register.html")
def setUp(self):
print "\n\n\n\n (2) DOING A SEARCH TEST \n\n\n\n"
self.client = app.test_client()
app.config['TESTING'] = True
postgrespassword = os.environ['POSTGRES_PASSWORD']
db_uri = 'postgresql://' + postgrespassword + '/test'
connect_to_db(app, db_uri)
db.create_all()
load_regions()
load_users()
load_bestuses()
load_categories()
load_brands()
load_products()
load_tents()
load_filltypes()
load_gendertypes()
load_sleepingbags()
load_padtypes()
load_sleepingpads()
load_ratings()
load_histories()
load_test_postalcodes()
def register():
model.connect_to_db()
if session.get("username"):
# get username by id
username = model.get_username_by_id(session["username"])
return redirect("users/"+username)
else:
return render_template("register.html")
def add_event():
model.connect_to_db()
title = request.args.get("title")
body = request.args.get("body")
user_id = request.args.get("user_id")
created_at = request.args.get("datestamp")
event = model.add_new_post(title, body, user_id, created_at)
return "Successfully added an event!"
def add_task_create():
model.connect_to_db()
title = request.args.get("title")
user_id = request.args.get("user_id")
created_at = request.args.get("datestamp")
row = model.new_task(title, created_at, user_id)
html = render_template("added_task.html")
return html
def view_user(username):
model.connect_to_db()
user_id = model.get_user_by_name(username)
wall_posts = model.get_wall_posts_for_user(user_id)
return render_template("wall_posts.html", username = username,
wall_posts = wall_posts,
user_id = session.get('user_id'))
def post_to_wall(username):
model.connect_to_db()
wall_owner = model.get_user_by_name(username)
current_user = session.get('user_id')
wall_content = request.form.get("wall_content")
model.add_wall_post(current_user, wall_owner, wall_content)
return redirect(url_for('view_user', username=username))
def post_to_wall(username):
model.connect_to_db()
owner_id = model.get_user_by_name(username)
author_id = session.get('user_id')
created_at = datetime.datetime.now()
content = request.form.get('content')
model.post_wall_posts(owner_id, author_id, created_at, content)
return redirect(url_for('view_user', username = username))
def setUp(self):
"""Set up app, session key, and fake client."""
app.config['TESTING'] = True
self.client = app.test_client()
connect_to_db(app, 'postgresql:///testdb')
db.create_all()
def setUp(self):
self.client = app.test_client()
app.config['TESTING'] = True
app.config['SECRET_KEY'] = 'BalloonicornSmash'
# Connect to the database
connect_to_db(app, db_uri=travis_db_uri)
# Reset the world so we start with clean data
seed_force(app)
def post_to_wall(username):
model.connect_to_db()
content = request.form.get("content")
author_id = session['user_id']
owner_id = model.get_user_by_name(username)
model.create_new_post(owner_id, author_id, content)
# redirect_string = "/user/%s" % username
return redirect(url_for('view_user', username=username))
def view_post(username):
model.connect_to_db()
post_text = request.form.get('post_text')
author_id = session.get('user_id')
owner_id = model.get_user_id_by_username(username)
model.insert_post(owner_id, author_id, post_text)
return redirect(url_for("view_user", username = username))
def setUp(self):
# Connect to test database
connect_to_db(app, "postgresql:///testdb")
# Create tables and add sample data
db.create_all()
example_data()
def setUpClass(cls):
"""Initializes the database."""
app = flask.Flask(__name__)
app.config['TESTING'] = True
model.connect_to_db(app, db_name='chat_client_test')
model.db.drop_all()
def setUp(self):
self.client = app.test_client()
app.config["TESTING"] = True
app.config["SECRET_KEY"] = "key"
connect_to_db(app, db_uri="postgresql:///testdb")
db.create_all()
def setUpClass(cls):
"""Initializes the test application."""
cls.client = server.app.test_client()
server.app.config['TESTING'] = True
model.connect_to_db(server.app, db_name='chat_client_test')
# Clear any data that may be in the database.
model.db.drop_all()
from flask import (Flask, render_template, redirect, request, flash,
session, copy_current_request_context, jsonify, current_app)
from flask_debugtoolbar import DebugToolbarExtension
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import func
import datetime
import urllib
from datetime import datetime
from server import app
import string
import os
from geopy import geocoders
from server import app
connect_to_db(app, 'postgresql:///safework')
#######################################################
with app.app_context():
db.drop_all()
db.create_all()
def fill_basics():
with app.app_context():
Police1 = Police(police_dept_id=1, name="User_Input")
Police2 = Police(police_dept_id=2, name="San Franciso Police Department", city="San Francisco", state="CA")
Police3 = Police(police_dept_id=3, name="Oakland Police Department", city="Oakland", state="CA")
Police4 = Police(police_dept_id=4, name="Alameda County Sheriff's Department", city="Oakland", state="CA")
Police5 = Police(police_dept_id=5, name="Santa Clara County Sheriff's Office", city="San Jose", state="CA")
Police6 = Police(police_dept_id=6, name="Fremont Police Department", city="Fremont", state="CA")
Police7 = Police(police_dept_id=7, name="San Leandro Police Department", city="San Leandro", state="CA")
Police8 = Police(police_dept_id=8, name="San Pablo Police Department", city="San Pablo", state="CA")
"""Script to seed database."""
import os
import csv
import crud
import model
from server import app
from decimal import Decimal
os.system('dropdb locations')
os.system('createdb locations')
model.connect_to_db(app)
model.db.create_all()
locations_in_db = []
with open('data/DoctorWhoEpisodesInfo.csv', encoding='utf-8-sig') as csv_file:
fieldnames = [
'season', 'episode_number', 'doctor', 'title', 'imdb', 'ep_id',
'companion', 'guest_star'
]
episode_data = csv.DictReader(csv_file,
fieldnames=fieldnames,
skipinitialspace=True)
#reads and imports Episode info from csv file
for episode in episode_data:
#for loop to set up database for episodes table and seeds data into episodes_in_db
"""Diplay about page"""
return render_template("about.html")
@app.route("/friends")
def display_friends():
"""Diplay list of contributors to open source code practice project"""
return render_template("friends.html")
@app.route("/api/tweets")
def create_api_endpoint():
"""Using ingested dsta from twitter create an API endpoint"""
tweedict = {}
tweets = Tweet.query.all()
for tweet in tweets:
tweedict[tweet.handle] = tweet.text
return jsonify(tweedict)
if __name__ == "__main__":
app.debug = True
connect_to_db(app, "postgresql:///newb")
app.run(port=5000)
tweet_to_db()
def delete_item(list_id, item):
print "I made it to the route"
model.connect_to_db()
model.delete_item(item)
return redirect(url_for("todo_list_show", id=list_id))
import os
import json
from random import choice, randint, sample
import requests, json, csv, time
from datetime import datetime
import crud, api
from model import connect_to_db, db, User, Symbol, Stock, Stockprice, Stockdetail, Stocknews, UserFavorite, Plan, Blog, Subscription, Stock_in_Subscription, Event, Comment
from server import app
os.system('dropdb stocks')
os.system('createdb stocks')
connect_to_db(app, echo=False)
db.create_all()
AA_API_KEY = os.environ['AA_API_KEY']
url = 'https://www.alphavantage.co/query?function=LISTING_STATUS&apikey=' + AA_API_KEY
res = requests.get(
url) # double check this line, might be a duplicate to line 65
decoded = res.content.decode('utf-8')
csv_read = csv.reader(decoded.splitlines(), delimiter=',')
all_symbols = list(csv_read)
for symbol in all_symbols:
symbol = Symbol(symbol=symbol[0])
db.session.add(symbol)
db.session.commit()
print("Finished adding all stock symbols")
email=testUserData[user]["email"], password=pass_hash)
db.session.add(testUser)
db.session.commit()
def addMessages():
"""add test message data to test db"""
for key in testGeojsonData:
message = Message(message_text=testGeojsonData[key]["message-text"], created_at=testGeojsonData[key]["time"], lat=testGeojsonData[key]
["lat"], lng=testGeojsonData[key]["lng"], country=testGeojsonData[key]["country"], city=testGeojsonData[key]["city"])
db.session.add(message)
db.session.commit()
def addLikedMessage():
"""add a message to liked list"""
for num in range(3, 5):
likeMessage = LikedMessage(message_id=num, user_id=2)
db.session.add(likeMessage)
db.session.commit()
addUsers()
addMessages()
#addLikedMessage()
if __name__ == "__main__":
connect_to_db(app, prod)
db.create_all()
create_test_data()
list_of_dates.append(date)
start_date = date
else:
break
return list_of_dates
def list_of_recurrent_entries_with_all_dates(list_of_recurrent_entries):
""" Return a list of recurrent entries associated with all dates based on frequency."""
updated_entry_list_with_new_dates = []
for entry in list_of_recurrent_entries:
date = entry.date
stop_date = entry.stop_date
frequency = entry.frequency
list_of_dates = find_all_dates(date, stop_date, frequency)
for date in list_of_dates:
entry_copy = copy.deepcopy(entry)
entry_copy.date = date
updated_entry_list_with_new_dates.append(entry_copy)
return updated_entry_list_with_new_dates
if __name__ == '__main__':
from server import app
local = "-local" in sys.argv
connect_to_db(app, local=local)
def setUp(self):
connect_to_db(app, "postgresql:///masseffecttest")
db.create_all()
make_test_data()
def get_mood_rating():
"""Gets ratings for a mood (day/event)"""
user_id = session['user_id']
overall_mood = request.form.get('overall-mood')
notes = request.form.get('notes')
# min and max mood are not req in html, will give empty str if not filled
# changes empty str to None in Python before passing it into Day instance
# prevents error when making record in db (min/max mood are integers)
if not request.form.get('min-mood'):
min_mood = None
max_mood = None
else:
min_mood = request.form.get('min-mood')
max_mood = request.form.get('max-mood')
return [user_id, overall_mood, min_mood, max_mood, notes]
if __name__ == "__main__":
# We have to set debug=True here, since it has to be True at the
# point that we invoke the DebugToolbarExtension
app.debug = False
connect_to_db(app, 'asgard_db')
# Use the DebugToolbar
DebugToolbarExtension(app)
app.run(port=5000, host='0.0.0.0')
}
else:
abort(400) # Bad request
return jsonify(dict_of_posts)
@app.route("/posts/<post_id>/references")
def references(post_id):
"""References by a particular post."""
mode = request.args.get('mode', 'full')
post = Post.query.filter(Post.id == post_id).one()
if mode == 'full':
dict_of_posts = {
post.id: post.to_dictionary()
for post in post.references
}
elif mode == 'short':
dict_of_posts = {post.id: post.title for post in post.references}
else:
abort(400) # Bad request
return jsonify(dict_of_posts)
if __name__ == '__main__':
connect_to_db(app, DB_URI)
app.run(debug=False, host="0.0.0.0")
items = PublicItem.query.all()
places = []
for item in items:
item_coordinates = [item.title, item.latitude, item.longitude]
places.append(item_coordinates)
# change back to UTF-8
for location in places:
location[0] = str(location[0])
return render_template("public-items-map.html",
gm_api_key=gm_api_key,
places=places,
email=email)
if __name__ == "__main__":
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
app.debug = True
app.jinja_env.auto_reload = app.debug # make sure templates, etc. are not cached in debug mode
if app.config['TESTING'] is True:
connect_to_db(app, "postgresql:///testdb")
else:
connect_to_db(app)
# Use the DebugToolbar
# DebugToolbarExtension(app)
app.run(port=5000, host='0.0.0.0')
""" Set value for the next category id after seeding database """
# Get the Max user id in the database
result = db.session.query(func.max(Category.id)).one()
max_id = int(result[0])
# Set the value for the next user_id to be max_id + 1
query = "SELECT setval('categories_id_seq', :new_id)"
db.session.execute(query, {'new_id': max_id + 1})
db.session.commit()
if __name__ == "__main__":
spent_database = os.getenv('POSTGRES_DB_URL', 'postgres:///spending')
connect_to_db(app, spent_database)
# In case tables haven't been created, create them
db.create_all()
# Import different types of data
load_users()
load_categories()
load_expenditures()
load_budget()
set_val_user_id()
set_val_category_id()
set_val_expenditure_id()
set_val_budget_id()
import pika
import requests
from qwer import qwer
from model import Job, connect_to_db
from model import db as alchemy_db
connect_to_db(qwer)
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='jobs')
def callback(ch, method, properties, body):
params = body.split()
r = requests.get(url=params[1])
job = Job.query.filter_by(id=params[0]).first()
job.data = r.text
alchemy_db.session.commit()
channel.basic_consume(callback,
queue='jobs',
no_ack=True)
print('Rabbit is waiting for messages. To exit press CTRL+C')
channel.start_consuming()
"""Script to seed test database"""
import os
import json
import crud
import model
import server
from random import choice
os.system("dropdb testbookworm")
os.system("createdb testbookworm")
model.connect_to_db(server.app, "testbookworm")
model.db.create_all()
def test_data():
#create books for testing
harry_potter = crud.create_book(
"oxxszQEACAAJ", "Harry Potter and the Half-Blood Prince",
"J. K. Rowling",
"Harry Potter, now sixteen-years-old, begins his sixth year at school in the midst of the battle between good and evil which has heated up with the return of the Dark Lord Voldemort.",
652,
"http://books.google.com/books/content?id=oxxszQEACAAJ&printsec=frontcover&img=1&zoom=1&source=gbs_api"
)
neverwhere = crud.create_book(
"yuCUZ3km3qIC", "Neverwhere", "Neil Gaiman",
"Richard Mayhew is a young man with a good heart and an ordinarylife, which is changed forever when he stops to help a girl he finds bleeding on a London sidewalk. His small act of kindness propels him into a world he never dreamed existed. There are people who fall through the cracks, and Richard has become one of them. And he must learn to survive in this city of shadows and darkness, monsters and saints, murderers and angels, if he is ever to return to the London that he knew.",
400,
@app.route('/seed')
def seed_and_update():
"""seed and update the database - temporart solution"""
update_station_status()
print 'Stations updated'
return '<h1>DB Seeded</h1>'
#---------------------------------------------------------------------#
# JSON Routes
#---------------------------------------------------------------------#
@app.route('/user-location.JSON')
def send_user_location_availability(location):
"""Gets location from the user and finds closest stations and availability"""
pass
if __name__ == "__main__":
app.debug = True
connect_to_db(app, 'postgres:///bike')
DebugToolbarExtension(app)
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.run(port=5000, host="0.0.0.0")
for url in urls:
if url.shortened_url[:2]=="0x":
created_count +=1
custom_count = len(urls)-created_count
return render_template('analytics.html', custom_count=custom_count, created_count=created_count, total=len(urls))
@app.route('/all_urls')
def show_all_urls():
"""Shows a list of all submitted URLs"""
urls = Url.query.all()
return render_template('all_urls.html', urls=urls)
if __name__ == "__main__":
app.debug = True
connect_to_db(app, 'postgresql:///urlshorten')
DebugToolbarExtension(app)
app.run()
"""Script to seed database"""
import os
import json
from random import choice, randint
from datetime import datetime
import crud
import model
import server
os.system('dropdb ratings')
os.system('createdb ratings')
model.connect_to_db(server.app)
model.db.create_all()
with open('data/movies.json') as f:
movie_data = json.loads(f.read())
# Create movies, store them in list so we can use them
# to create fake ratings later
movies_in_db = []
for movie in movie_data:
title = movie.get('title')
overview = movie.get('overview')
poster_path = movie.get('poster_path')
release_str = movie.get('release_date')
format = "%Y-%m-%d"
release_date = datetime.strptime(release_str, format)
# Commit to push to database
db.session.commit()
def set_val_user_id():
"""Set value for the next user_id after seeding database"""
# Get the Max user_id in the database
result = db.session.query(func.max(User.user_id)).one()
max_id = int(result[0])
# Set the value for the next user_id to be max_id + 1
query = "SELECT setval('users_user_id_seq', :new_id)"
db.session.execute(query, {'new_id': max_id + 1})
db.session.commit()
if __name__ == "__main__":
connect_to_db(app)
# In case tables haven't been created, create them
db.create_all()
# Import different types of data
load_users()
load_movies()
load_ratings()
set_val_user_id()
def setUp(self):
"""Stuff to do before every test."""
self.client = server.app.test_client()
server.app.config['TESTING'] = True
server.app.config['SECRET_KEY'] = 'key'
# Connect to test database (uncomment when testing database)
connect_to_db(server.app, "testdb")
# Create tables and add sample data (uncomment when testing database)
db.create_all()
example_data()
self.old_api = api.yelp_api_call
def _mock_yelp_api_call(payload_str):
"""Mock results of yelp api call at api.py"""
return {'businesses':[{'id': 'GLW_lWB5K-4eHX-2RfzJ5g',
'alias': 'davis-poultry-farms-gilroy-10',
'name': 'Davis Poultry Farms',
'image_url': 'https://s3-media1.fl.yelpcdn.com/bphoto/iRY9a_oHXJtLi1W8NDrSbQ/o.jpg',
'is_closed': False,
'url': 'https://www.yelp.com/biz/davis-poultry-farms-gilroy-2?adjust_creative=vxvAyk47rIbZXQHuMg79ww&utm_campaign=yelp_api_v3&utm_medium=api_v3_business_search&utm_source=vxvAyk47rIbZXQHuMg79ww',
'review_count': 15,
'categories': [{'alias': 'ranches', 'title': 'Ranches'}],
'rating': 4.5,
'coordinates': {'latitude': 37.0531099,
'longitude': -121.59012},
'transactions': [],
'location': {'address1': '155 Santa Clara Ave',
'address2': '',
'address3': '',
'city': 'Gilroy',
'zip_code': '95020',
'country': 'US',
'state': 'CA',
'display_address': ['155 Santa Clara Ave', 'Gilroy, CA 95020']},
'phone': '+14088424894',
'display_phone': '(408) 842-4894',
'distance': 21479.493719243506}]}
api.yelp_api_call = _mock_yelp_api_call
def _mock_request_get(YELP_SEARCH_URL, headers, params):
"""Mock yelp api request for business search"""
class MockResult:
"""Mock result of api request"""
def json(self):
return {'businesses':[{'id': 'GLW_lWB5K-4eHX-2RfzJ5g',
'alias': 'davis-poultry-farms-gilroy-10',
'name': 'Davis Poultry Farms',
'image_url': 'https://s3-media1.fl.yelpcdn.com/bphoto/iRY9a_oHXJtLi1W8NDrSbQ/o.jpg',
'is_closed': False,
'url': 'https://www.yelp.com/biz/davis-poultry-farms-gilroy-2?adjust_creative=vxvAyk47rIbZXQHuMg79ww&utm_campaign=yelp_api_v3&utm_medium=api_v3_business_search&utm_source=vxvAyk47rIbZXQHuMg79ww',
'review_count': 15,
'categories': [{'alias': 'ranches', 'title': 'Ranches'}],
'rating': 4.5,
'coordinates': {'latitude': 37.0531099,
'longitude': -121.59012},
'transactions': [],
'location': {'address1': '155 Santa Clara Ave',
'address2': '',
'address3': '',
'city': 'Gilroy',
'zip_code': '95020',
'country': 'US',
'state': 'CA',
'display_address': ['155 Santa Clara Ave', 'Gilroy, CA 95020']},
'phone': '+14088424894',
'display_phone': '(408) 842-4894',
'distance': 21479.493719243506}]}
my_result = MockResult()
return my_result
api.requests.get = _mock_request_get
for post in posts:
post.event_date = post.event_date.strftime('%m/%d/%Y %I:%M %P')
user = User.query.filter_by(user_id=post.user_id).first()
post.username = user.username
return render_template("post_list.html", posts=posts)
# for heroku debugging
@app.route("/error")
def error():
raise Exception("Error!")
if __name__ == '__main__':
connect_to_db(app, os.environ.get("DATABASE_URL"))
# Create the tables we need from our models (if they already
# exist, nothing will happen here, so it's fine to do this each
# time on startup)
db.create_all(app=app)
# Use the DebugToolbar
app.debug = False
DebugToolbarExtension(app)
app.jinja_env.auto_reload = app.debug # make sure templates, etc. are not cached in debug mode
DEBUG = "NO_DEBUG" not in os.environ
# app.run(port=5000, host='0.0.0.0')
PORT = int(os.environ.get("PORT", 5000))
"""Display list of contributors to open source code practice project"""
return render_template("friends.html")
@app.route("/api/tweets")
def create_api_endpoint():
"""Using ingested dsta from twitter create an API endpoint"""
tweedict = {}
tweets = Tweet.query.all()
for tweet in tweets:
tweedict[tweet.handle] = tweet.text
return jsonify(tweedict)
@app.route("/archives")
def archives():
""" Displays previous tweets """
return render_template("archives.html")
if __name__ == "__main__":
app.debug = True
# Change the postgresql info below username, password, port
connect_to_db(app, "postgresql://*****:*****@localhost:port/newb")
app.run(port=5000)
# for user_playlist in user.playlists:
# if user_playlist.playlist_title == playlist.playlist_title:
# playlist = user_playlist
for song in artist.songs:
playlist.songs.append(song)
db.session.commit()
def db_create_playlist(artist_name, playlist_title, user_id):
artist = add_artist_to_db(artist_name)
setlists = load_setlists_from_artist(artist)
add_songs_to_db(artist, setlists)
playlist = create_playlist_in_db(playlist_title, user_id)
add_songs_to_playlist(artist, user_id, playlist)
if __name__ == "__main__":
connect_to_db(server.app)
# In case tables haven't been created, create them
db.create_all()
# Import different types of data
# load_users()
from doctest import testmod
if testmod().failed == 0:
print("Setlist API tests passed.")