def client():
"""Yields a flask test client fixture for testing http requests.
"""
app = create_app("testing")
flaskapp = app.app
test_client = flaskapp.test_client()
ctx = flaskapp.app_context()
ctx.push()
db.reflect() # Necessary for PostgreSQL
db.engine.execute("DROP EXTENSION IF EXISTS postgis CASCADE;")
db.drop_all()
db.engine.execute("CREATE EXTENSION postgis;")
db.create_all()
yield test_client
db.session.remove()
db.engine.execute("DROP EXTENSION postgis CASCADE;")
db.drop_all()
ctx.pop()
def init_db():
# Reflect all tables from database
db.reflect()
# Try to drop all tables
db.drop_all()
# Re-initiate all tables
db.create_all()
click.echo('Initialized the database.')
def setUp(self):
app.config['TESTING'] = True
app.config['DEBUG'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
self.app = app.test_client()
db.reflect()
db.drop_all()
db.create_all()
def recreate_db():
"""
Recreates a local database. You probably should not use this on
production.
"""
db.reflect()
db.drop_all()
db.create_all()
db.session.commit()
def add_projectt():
project = Project(description="description", user_id=1, status=ProjectStatus.active)
db.session.add(project)
db.session.commit()
db.reflect()
db.drop_all()
return jsonify(project.serialize())
def db_rebuild():
"""
Destroy and rebuild database with fake data.
"""
# destroy and rebuild tables
db.reflect()
db.drop_all()
db.create_all()
# insert locations as defined in model
Location.insert_locations()
# insert roles as defined in model
Role.insert_roles()
# insert geos and usertypes as defined in model
Geo.insert_geos()
UserType.insert_user_types()
# insert education data
Education.create_education()
# insert fake admin/test users
from random import seed
import forgery_py
seed()
test_user_1 = User(email='*****@*****.**',
username='******',
password='******',
app_name='password'.encode('base64'),
confirmed=True,
name='David Kimaru',
location='KE',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
admin_user = User(email='*****@*****.**',
username='******',
password='******',
app_name='webmaster'.encode('base64'),
confirmed=True,
name='Web Master',
location='UG',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
db.session.add_all([test_user_1, admin_user])
db.session.commit()
# insert fake user data
# User.generate_fake(60)
# print results
inspector = db.inspect(db.engine)
print('The following tables were created.')
print('-' * 17)
for table in inspector.get_table_names():
print(table)
def db_rebuild():
"""
Destroy and rebuild database with fake data.
"""
# destroy and rebuild tables
db.reflect()
db.drop_all()
db.create_all()
# insert fake test users
test_user_1 = User(
email='*****@*****.**',
username='******',
password='******',
confirmed=True,
)
test_user_2 = User(
email='*****@*****.**',
username='******',
password='******',
confirmed=True,
)
db.session.add_all([test_user_1, test_user_2])
db.session.commit()
# insert fake user data
User.generate_fake(60)
# insert fake conferences
FootballConference.generate_fake(20)
# insert fake fantasy leagues
FantasyLeague.generate_fake(20)
# insert fake fantasy teams
FantasyTeam.generate_fake()
# insert fake football teams
FootballTeam.generate_fake(80)
# insert fake football players
FootballPlayer.generate_fake(3000)
# insert fake draft orders
DraftOrder.generate_fake(rounds=5)
# complete draft
# do not complete the draft when creating fake data
# DraftPick.generate_fake()
# print results
inspector = db.inspect(db.engine)
print 'The following tables were created.'
print '-' * 35
for table in inspector.get_table_names():
print table
def seed_stores(member_store, post_store):
db.reflect()
db.drop_all()
db.create_all()
for member in dummy_members:
member_store.add(member)
for post in dummy_posts:
post_store.add(post)
def tearDown(self):
"""
Tear down the environment after each executed test.
:return: Nothing.
"""
# Remove the session and drop de DB
db.session.remove()
db.reflect()
db.drop_all()
# Delete the SQLite file
os.remove(db.session.bind.url.database)
def tearDown(self):
"""
Remove the registries and delete the DB at the end of each test.
:return: Nothing.
"""
# Remove the session and drop de DB
db.session.remove()
db.reflect()
db.drop_all()
# Delete the SQLite file
os.remove(db.session.bind.url.database)
def db(request, app):
"""Create test database tables"""
_db.reflect()
_db.drop_all()
# Create the tables based on the current model
_db.create_all()
MembershipRole._MembershipRole__insert_defaults()
Country._Country__insert_defaults()
# user = User.create_test_user()
testfixture.testdata.addyaml()
user = User.query.filter_by(name="certmaster").first()
TestClient.test_user = user
TestClient._api_user = user
TestClient.test_user.organization_id = Organization.query.filter_by(abbreviation='cert').first().id
app.test_client_class = TestClient
app.response_class = TestResponse
_db.session.commit()
def db_rebuild():
"""
Destroy and rebuild database with fake data.
"""
# destroy and rebuild tables
db.reflect()
db.drop_all()
db.create_all()
# insert fake test users
test_user_1 = User(email="*****@*****.**", username="******", password="******", confirmed=True)
test_user_2 = User(email="*****@*****.**", username="******", password="******", confirmed=True)
db.session.add_all([test_user_1, test_user_2])
db.session.commit()
# insert fake user data
User.generate_fake(60)
# insert fake conferences
FootballConference.generate_fake(20)
# insert fake fantasy leagues
FantasyLeague.generate_fake(20)
# insert fake fantasy teams
FantasyTeam.generate_fake()
# insert fake football teams
FootballTeam.generate_fake(80)
# insert fake football players
FootballPlayer.generate_fake(3000)
# insert fake draft orders
DraftOrder.generate_fake(rounds=5)
# complete draft
# do not complete the draft when creating fake data
# DraftPick.generate_fake()
# print results
inspector = db.inspect(db.engine)
print "The following tables were created."
print "-" * 35
for table in inspector.get_table_names():
print table
def setUp(self):
app.config['TESTING'] = True
app.config['DEBUG'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
self.app = app.test_client()
db.reflect()
db.drop_all()
db.create_all()
# Add dummy metadata
self.user_category = UserCategory('Postdoc')
db.session.add(self.user_category)
self.country = Country('South Africa')
db.session.add(self.country)
# Add a dummy organisation
self.add_organisation(domain='org')
db.session.flush()
def client():
"""Yields a flask test client fixture for testing http requests.
"""
app = create_app("testing")
flaskapp = app.app
test_client = flaskapp.test_client()
ctx = flaskapp.app_context()
ctx.push()
db.reflect() # Necessary for PostgreSQL
db.drop_all()
db.create_all()
yield test_client
db.session.remove()
db.drop_all()
ctx.pop()
__author__ = 'jonathan' from app import db from app.models import User db.reflect() db.drop_all() db.create_all()
def tearDown(self):
db.session.remove()
db.reflect()
db.drop_all()
def drop_db():
db.session.commit()
db.reflect()
db.drop_all()
def drop_db():
db.reflect()
db.drop_all()
click.echo('The database was droped!')
def tearDown(self):
with self.app.app_context():
db.session.remove()
db.reflect()
db.drop_all()
def init_db():
"""Create Database Tables"""
db.reflect()
db.drop_all() # drop all tables for preventing polluting new data
db.create_all()
click.echo('Successfully Create All DB Tables!')
def db_import():
"""Initialize the database."""
click.echo('Database initialization')
MOCK_DB = None
with open('fixtures/mock.json', 'r') as mock:
MOCK_DB = json.load(mock)
click.echo('Resetting db...')
db.reflect()
db.drop_all()
db.create_all()
click.echo('Adding items...')
local_items = []
for item in MOCK_DB['items']:
item_row = Item(item)
db.session.add(item_row)
local_items += [item_row]
local_skills = []
for skill in MOCK_DB['skills']:
skill_row = Skill(skill)
db.session.add(skill_row)
local_skills += [skill_row]
local_videos = []
for video in MOCK_DB['videos']:
video_row = Video(video)
db.session.add(video_row)
local_videos += [video_row]
local_reddits = []
for reddit in MOCK_DB['reddits']:
reddit_row = Reddit(reddit)
db.session.add(reddit_row)
local_reddits += [reddit_row]
for json_item in MOCK_DB['items']:
db_item = local_items[json_item['id'] - 1]
for skill_id in json_item['skills']:
db_item.skills.append(local_skills[skill_id - 1])
for reddit_id in json_item['reddits']:
db_item.reddits.append(local_reddits[reddit_id - 1])
for video_id in json_item['videos']:
db_item.videos.append(local_videos[video_id - 1])
db.session.add(db_item)
for json_skill in MOCK_DB['skills']:
db_skill = local_skills[json_skill['id'] - 1]
for item_id in json_skill['items']:
db_skill.items.append(local_items[item_id - 1])
for reddit_id in json_skill['reddits']:
db_skill.reddits.append(local_reddits[reddit_id - 1])
for video_id in json_skill['videos']:
db_skill.videos.append(local_videos[video_id - 1])
db.session.add(db_skill)
for json_video in MOCK_DB['videos']:
db_video = local_videos[json_video['id'] - 1]
for item_id in json_video['items']:
db_video.items.append(local_items[item_id - 1])
for skill_id in json_video['skills']:
db_video.skills.append(local_skills[skill_id - 1])
db.session.add(db_video)
for json_reddit in MOCK_DB['reddits']:
db_reddit = local_reddits[json_reddit['id'] - 1]
for item_id in json_reddit['items']:
db_reddit.items.append(local_items[item_id - 1])
for skill_id in json_reddit['skills']:
db_reddit.skills.append(local_skills[skill_id - 1])
db.session.add(db_reddit)
click.echo('Reindexing for elasticsearch...')
db.session.commit()
Item.reindex()
Skill.reindex()
Reddit.reindex()
Video.reindex()
click.echo('Done.')
def after_all(context):
"""Destroy the context bag."""
with context.app.app_context():
db.reflect()
db.drop_all()
def tearDown(self):
db.session.remove()
db.reflect()
db.drop_all()
self.app_context.pop()
def drop_db():
from app import db
db.reflect()
db.drop_all()
def db_rebuild():
"""
Destroy and rebuild database with fake data.
"""
# destroy and rebuild tables
db.reflect()
db.drop_all()
db.create_all()
# insert roles as defined in model
Role.insert_roles()
# insert geos and usertypes as defined in model
Geo.insert_geos()
UserType.insert_user_types()
# insert firm types/tiers as defined in model
FirmType.insert_firm_types()
FirmTier.insert_firm_tiers()
# insert fake admin/test users
from random import seed
import forgery_py
seed()
test_user_1 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Salim Hamed',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
test_user_2 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bryan Davis',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
test_user_3 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Joe Smith',
location='San Francisco, CA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
test_user_4 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bill Gates',
location='Bellevue, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
admin_user = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bill Gates',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
db.session.add_all(
[test_user_1, test_user_2, test_user_3, test_user_4, admin_user])
db.session.commit()
# insert fake user data
User.generate_fake(60)
# insert fake post data
Post.generate_fake(400)
# insert fake followers
Follow.generate_fake(2000)
# insert fake firms
Firm.generate_fake(5000)
# insert fake companies
Company.generate_fake(10000)
# insert fake relationships
Relationship.generate_fake(60000)
# print results
inspector = db.inspect(db.engine)
print('The following tables were created.')
print('-' * 17)
for table in inspector.get_table_names():
print(table)
from app import app, db
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import backref
from sqlalchemy import and_
Base = declarative_base()
metadata = Base.metadata
db.reflect()
class Article(db.Model):
__tablename__ = 'article'
entities = db.relationship("Entity", secondary="article_entity")
def serialize(self):
# TODO: FIGURE OUT TOP ENTITIES EFFICIENTLY
#top_entities = Entity.query.join(ArticleEntity, Entity.id == ArticleEntity.entity_id).add_columns(
# ArticleEntity.score).filter(ArticleEntity.article_id == self.id).order_by(ArticleEntity.score.desc()).limit(3).all()
return {
'id': self.id,
'title': self.title,
'description': self.description,
'source': self.source,
'url': self.url,
'image_url': self.image_url,
'date_created': self.date_created,
'entities': [e.serialize() for e in self.entities]
def createdb():
from app import db
db.reflect()
db.drop_all()
db.create_all()
from app import app, db
with app.app_context():
print db.reflect()
# print db.metadata.schema
# print db.metadata.tables
ResDesc = db.metadata.tables['res_desc']
# print dir(ResTyp)
# res_select = ResTyp.select().where(ResTyp.columns.ID == 0)
# print dir(res_select)
# result = db.session.execute(res_select)
# for row in result:
# print row
#print dir(db.session)
#print dir(db.metadata)
def db_rebuild():
"""
Destroy and rebuild database with fake data.
"""
# destroy and rebuild tables
db.reflect()
db.drop_all()
db.create_all()
# insert roles as defined in model
Role.insert_roles()
# insert geos and usertypes as defined in model
Geo.insert_geos()
UserType.insert_user_types()
# insert firm types/tiers as defined in model
FirmType.insert_firm_types()
FirmTier.insert_firm_tiers()
# insert fake admin/test users
from random import seed
import forgery_py
seed()
test_user_1 = User(
email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Salim Hamed',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True)
)
test_user_2 = User(
email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bryan Davis',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True)
)
test_user_3 = User(
email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Joe Smith',
location='San Francisco, CA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True)
)
test_user_4 = User(
email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bill Gates',
location='Bellevue, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True)
)
admin_user = User(
email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bill Gates',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True)
)
db.session.add_all([test_user_1, test_user_2, test_user_3, test_user_4,
admin_user])
db.session.commit()
# insert fake user data
User.generate_fake(60)
# insert fake post data
Post.generate_fake(400)
# insert fake followers
Follow.generate_fake(2000)
# insert fake firms
Firm.generate_fake(5000)
# insert fake companies
Company.generate_fake(10000)
# insert fake relationships
Relationship.generate_fake(60000)
# print results
inspector = db.inspect(db.engine)
print 'The following tables were created.'
print '-'*17
for table in inspector.get_table_names():
print table
def reflect_db():
db.reflect()
def db_drop():
db.reflect()
db.drop_all()
from app import db, app
"""
You can use the extra Flask-AppBuilder fields and Mixin's
AuditMixin will add automatic timestamp of created and modified by who
"""
# idea came from this: https://stackoverflow.com/a/36337815/2130789
db.reflect(app=app)
class Competitions(db.Model):
__bind_key__ = 'teamsdb'
__tablename__ = 'competitions'
__table_args__ = (
db.CheckConstraint(u'age_group in (9,10,12,14,16,18,20,21)'),
db.CheckConstraint(u"gender in ('F','M')"),
db.CheckConstraint(u'section >= 1 and section <= 15'),
{'extend_existing': True, 'autoload': True,
'autoload_with': db.get_engine(app, 'teamsdb')}
)
class Venues(db.Model):
__bind_key__ = 'teamsdb'
def erase_db():
a = input('Do you want to eresa and dele db (y/n)?')
if a == 'y':
db.reflect()
db.drop_all()
def drop_tables():
"""drop all tables"""
db.reflect()
db.drop_all()
