def _create_storage(self):
engine = sql.create_engine("sqlite://")
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(engine=engine,
metadata=metadata,
table_name=self.given_table_name)
metadata.create_all()
def _create_storage(self):
engine = sql.create_engine(SQLALCHEMY_DATABASE_URI)
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(
engine=engine,
metadata=metadata,
table_name=self.given_table_name,
hooks=[sumUrl, sumRemote, sumUserAgent, sumLanguage, sumServer])
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
bcrypt.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
from flaskblog.users.routes import users
from flaskblog.posts.routes import posts
from flaskblog.main.routes import main
from flaskblog.brands.routes import brands
from flaskblog.visits.routes import visits
from flaskblog.errors.handlers import errors
app.register_blueprint(users)
app.register_blueprint(posts)
app.register_blueprint(main)
app.register_blueprint(brands)
app.register_blueprint(visits)
app.register_blueprint(errors)
with app.app_context():
t.init_app(app, [PrintWriter(), OutputWriter(), SQLStorage(db=db)])
return app
def _create_storage(self):
engine = sql.create_engine(
"mysql+mysqldb://travis:@localhost/track_usage_test")
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(engine=engine,
metadata=metadata,
table_name=self.given_table_name)
metadata.create_all()
def _create_storage(self):
engine = sql.create_engine("sqlite://")
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(
engine=engine,
metadata=metadata,
table_name=self.given_table_name
)
metadata.create_all()
def _create_storage(self):
engine = sql.create_engine(
"postgresql+psycopg2://postgres:@localhost/track_usage_test")
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(
engine=engine,
metadata=metadata,
table_name=self.given_table_name,
hooks=[sumUrl, sumRemote, sumUserAgent, sumLanguage, sumServer])
metadata.create_all()
class TestSQLiteStorage(FlaskTrackUsageTestCase):
def _create_storage(self):
engine = sql.create_engine("sqlite://")
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(engine=engine,
metadata=metadata,
table_name=self.given_table_name)
metadata.create_all()
def tearDown(self):
meta = sql.MetaData()
meta.reflect(bind=self.storage._eng)
for table in reversed(meta.sorted_tables):
self.storage._eng.execute(table.delete())
def setUp(self):
self.given_table_name = 'my_usage'
FlaskTrackUsageTestCase.setUp(self)
self.blueprint = Blueprint('blueprint', __name__)
@self.blueprint.route('/blueprint')
def blueprint():
return "blueprint"
self.app.register_blueprint(self.blueprint)
self._create_storage()
self.track_usage = TrackUsage(self.app, self.storage)
self.track_usage.include_blueprint(self.blueprint)
def test_table_name(self):
meta = sql.MetaData()
meta.reflect(bind=self.storage._eng)
assert self.given_table_name == meta.tables.keys()[0]
def test_storage_data_basic(self):
self.client.get('/')
con = self.storage._eng.connect()
s = sql.select([self.storage.track_table])
result = con.execute(s).fetchone()
#assert result[0] == 1 # first row
assert result[1] == u'http://localhost/'
assert result[2] is None
assert result[3] is None
assert result[4] is None
assert result[5] is None
assert result[6] is None
assert result[8] == 200
self.assertTrue(result[9])
assert result[10] == None
assert result[11] == False
assert result[12] is None
assert result[13] == '/'
assert result[14].__class__ is float
assert type(result[15]) is datetime.datetime
def test_storage_data_blueprint(self):
self.client.get('/blueprint')
con = self.storage._eng.connect()
s = sql.select([self.storage.track_table])
result = con.execute(s).fetchone()
assert result[1] == u'http://localhost/blueprint'
assert result[2] is None
assert result[3] is None
assert result[4] is None
assert result[5] is None
assert result[6] == 'blueprint'
assert result[8] == 200
self.assertTrue(result[9])
assert result[10] is None
assert result[11] == False
assert result[12] is None
assert result[13] == '/blueprint'
assert result[14].__class__ is float
assert type(result[15]) is datetime.datetime
def test_storage__get_raw(self):
# First check no blueprint case get_usage is correct
self.client.get('/')
result = self.storage._get_raw()[0]
assert result[1] == u'http://localhost/'
assert result[2] is None
assert result[3] is None
assert result[4] is None
assert result[5] is None
assert result[6] is None
assert result[8] == 200
self.assertTrue(result[9])
assert result[10] is None
assert result[11] == False
assert result[12] is None
assert result[13] == '/'
assert result[14].__class__ is float
assert type(result[15]) is datetime.datetime
# Next check with blueprint the get_usage is correct
self.client.get('/blueprint')
rows = self.storage._get_raw()
print rows[1]
result = rows[1] # if rows[0][6] is None else rows[0]
#assert result[0] == 2 # first row
assert result[1] == u'http://localhost/blueprint'
assert result[2] is None
assert result[3] is None
assert result[4] is None
assert result[5] is None
assert result[6] == 'blueprint'
assert result[8] == 200
self.assertTrue(result[9])
assert result[10] is None
assert result[11] == False
assert result[12] is None
assert result[13] == '/blueprint'
assert result[14].__class__ is float
assert type(result[15]) is datetime.datetime
# third get
self.client.get('/')
# Limit tests
assert len(self.storage._get_raw()) == 3
assert len(self.storage._get_raw(limit=2)) == 2
assert len(self.storage._get_raw(limit=1)) == 1
# timing tests
# give a 5 second lag since datetime stored is second precision
now = datetime.datetime.utcnow() + datetime.timedelta(0, 5)
assert len(self.storage._get_raw(start_date=now)) == 0
assert len(self.storage._get_raw(end_date=now)) == 3
assert len(self.storage._get_raw(end_date=now, limit=2)) == 2
def test_storage__get_usage(self):
self.client.get('/')
result = self.storage._get_raw()[0]
result2 = self.storage._get_usage()[0]
#assert result[0] == 1 # first row
assert result[1] == result2['url']
assert result[2] == result2['user_agent']['browser']
assert result[3] == result2['user_agent']['language']
assert result[4] == result2['user_agent']['platform']
assert result[5] == result2['user_agent']['version']
assert result[6] == result2['blueprint']
assert result[8] == result2['status']
assert result[9] == result2['remote_addr']
assert result[10] == result2['xforwardedfor']
assert result[11] == result2['authorization']
assert result[12] == result2['ip_info']
assert result[13] == result2['path']
assert result[14] == result2['speed']
assert result[15] == result2['date']
def test_storage_get_usage(self):
self.client.get('/')
result = self.storage._get_raw()[0]
result2 = self.storage.get_usage()[0]
#assert result[0] == 1 # first row
assert result[1] == result2['url']
assert result[2] == result2['user_agent']['browser']
assert result[3] == result2['user_agent']['language']
assert result[4] == result2['user_agent']['platform']
assert result[5] == result2['user_agent']['version']
assert result[6] == result2['blueprint']
assert result[8] == result2['status']
assert result[9] == result2['remote_addr']
assert result[10] == result2['xforwardedfor']
assert result[11] == result2['authorization']
assert result[12] == result2['ip_info']
assert result[13] == result2['path']
assert result[14] == result2['speed']
assert result[15] == result2['date']
def test_storage_get_usage_pagination(self):
# test pagination
for i in range(100):
self.client.get('/')
limit = 10
num_pages = 10
for page in range(1, num_pages + 1):
result = self.storage._get_usage(limit=limit, page=page)
assert len(result) == limit
# actual api test
result = self.storage._get_raw(limit=100) # raw data
result2 = self.storage.get_usage(limit=100) # dict data
for i in range(100):
assert result[i][1] == result2[i]['url']
assert result[i][2] == result2[i]['user_agent']['browser']
assert result[i][3] == result2[i]['user_agent']['language']
assert result[i][4] == result2[i]['user_agent']['platform']
assert result[i][5] == result2[i]['user_agent']['version']
assert result[i][6] == result2[i]['blueprint']
assert result[i][8] == result2[i]['status']
assert result[i][9] == result2[i]['remote_addr']
assert result[i][10] == result2[i]['xforwardedfor']
assert result[i][11] == result2[i]['authorization']
assert result[i][12] == result2[i]['ip_info']
assert result[i][13] == result2[i]['path']
assert result[i][14] == result2[i]['speed']
assert result[i][15] == result2[i]['date']
from flask import Flask, g
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
# Set the configuration items manually for the example
app.config['TRACK_USAGE_USE_FREEGEOIP'] = True
app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include'
from flask_track_usage import TrackUsage
from flask_track_usage.storage.printer import PrintWriter
from flask_track_usage.storage.output import OutputWriter
from flask_track_usage.storage.sql import SQLStorage
# Make an instance of the extension and put two writers
app.config['SECRET_KEY'] = '5791628bb0b13ce0c676dfde280ba245'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
db = SQLAlchemy(app)
t = TrackUsage(app, SQLStorage(db=db))
# Include the view in the metrics
@t.include
@app.route('/')
def index():
#g.track_var["optional"] = "something"
return "Hello"
# Run the application!
app.run(debug=True)
database = '/ppt.db'
def get_db():
db = getattr(g, '_database', None)
if db is None:
db = g._database = sqlite3.connect(database)
return db
# PostgreSQL Setup
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///ppt.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
sql_db = SQLAlchemy(app)
# Track Usage Setup
# mstore = MongoEngineStorage()
pstore = SQLStorage(db=sql_db)
t = TrackUsage(app, [pstore])
@app.route('/')
def home():
return render_template("homepage.html")
@app.route('/property_form', methods=['POST', 'GET'])
def property_form():
if request.method == "POST":
# Retrieve buyer citizenship
buying_status = request.form['buyAs']
app.config['SECURITY_PASSWORD_SALT'] = os.environ['FLASK_SALT']
app.config['SECURITY_MANAGER'] = Security(
app, SQLAlchemyUserDatastore(manager.database, md.User, md.Role))
# Setup Flask-Session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = manager.server
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=100)
app.config['SESSION_MANAGER'] = Session(app)
# Setup Flask-TrackUsage
app.config['TRACK_USAGE_COOKIE'] = True
app.config['TRACK_USAGE_USE_FREEGEOIP'] = False
app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude'
with app.app_context():
storage = SQLStorage(db=manager.database)
t = TrackUsage(app, storage)
# Allows compression of text assets
# If the server has automatic compression, comment this line.
compress = Compress(app)
# Setup Flask-Babel
app.config['LANGUAGES'] = ['en', 'fr']
app.config['BABEL_TRANSLATION_DIRECTORIES'] = 'translations'
babel = Babel(app)
@app.template_filter('autoversion')
def autoversion_filter(filename):
fullpath = os.path.join('', filename[1:])
from datetime import datetime
import datetime
import pandas as pd
import json
from flask_track_usage.storage.sql import SQLStorage
from flask_track_usage import TrackUsage
app = Flask(__name__)
basedir = os.path.abspath(os.path.dirname(__file__))
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'ridedb.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
ma = Marshmallow(app)
pstore = SQLStorage(db=db)
t = TrackUsage(app, [pstore])
db.metadata.clear()
def check_timestamp_24(timestamp):
date_format = '%d-%m-%Y:%S-%M-%H'
try:
datetime1 = datetime.datetime.strptime(timestamp, date_format)
value = True
except ValueError:
value = False
if value:
current = datetime.datetime.utcnow()
if current <= datetime1:
# create database for data
db = SQLAlchemy(app,
metadata=MetaData(naming_convention=naming_convention),
model_class=BaseModel)
migrate = Migrate(app=app, db=db)
#altre magie per sqlalchemy per sqlite
with app.app_context():
if db.engine.url.drivername == 'sqlite':
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
#
# TrackUsage setup
#
track_datastore = SQLStorage(engine=db.get_engine(bind="trackusage"))
t = TrackUsage(app, [track_datastore])
from app import routes, errors, models
from app.models import Users, Roles, Tokens, TokenTypes, Apis, TokenApiCounters
from app.models import Languages, ErrorGroups, ErrorCodes, ErrorTranslations
from app.models import Area, Location, Neighborhood, Poi, PoiCategory, PoiCategoryType, Street
from app.models import FlaskUsage
from app.models import Ideas
from app.models import Errors, Feedbacks
#
# Users setup
#
user_datastore = SQLAlchemyUserDatastore(db, Users, Roles)
security = Security(app, user_datastore)
def _create_storage(self):
self.storage = SQLStorage(
conn_str="sqlite://",
table_name=self.given_table_name
)
def _create_storage(self):
engine = sql.create_engine(SQLALCHEMY_DATABASE_URI)
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(engine=engine,
metadata=metadata,
table_name=self.given_table_name)
class TestMySQLStorage(FlaskTrackUsageTestCase):
def _create_storage(self):
engine = sql.create_engine(SQLALCHEMY_DATABASE_URI)
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(engine=engine,
metadata=metadata,
table_name=self.given_table_name)
# metadata.create_all()
def tearDown(self):
"""
Delete the table
"""
self.storage.track_table.drop(self.storage._eng)
def setUp(self):
"""
Create the app, track usage and init storage
"""
self.given_table_name = 'my_usage'
FlaskTrackUsageTestCase.setUp(self)
self._create_storage()
self.track_usage = TrackUsage()
self.track_usage.init_app(self.app, self.storage)
# self.track_usage.include_blueprint(self.blueprint)
def test_table_name(self):
meta = sql.MetaData()
meta.reflect(bind=self.storage._eng)
print(self.given_table_name, list(meta.tables.keys())[0])
self.assertIn(self.given_table_name, meta.tables.keys())
def test_storage_data_basic(self):
self.client.get('/')
result = self.storage.track_table.select().execute().first()
assert result['id'] == 1 # first row
assert result['url'] == u'http://localhost/'
assert result['ua_browser'] is None
assert result['ua_language'] is None
assert result['ua_platform'] is None
assert result['ua_version'] is None
assert result['blueprint'] is None
assert result['view_args'] == '{}'
assert result['status'] == 200
assert result['remote_addr'] == '127.0.0.1'
assert result['xforwardedfor'] is None
assert result['authorization'] is False
assert result['ip_info'] is None
assert result['path'] == '/'
assert result['speed'] > 0
assert type(result['date']) is datetime.datetime
assert result['username'] is None
assert result['track_var'] == '{}'
def test_storage_get_usage_pagination(self):
# test pagination
for i in range(100):
self.client.get('/')
limit = 10
num_pages = 10
for page in range(1, num_pages + 1):
result = self.storage._get_usage(limit=limit, page=page)
assert len(result) == limit
# actual api test
result = self.storage._get_raw(limit=100) # raw data
result2 = self.storage.get_usage(limit=100) # dict data
for i in range(100):
for key in result[i].keys():
if key == 'id':
assert key not in result2[i]
assert key in result[i]
elif 'ua_' in key:
result[i][key] == result2[i]['user_agent'][key.split('_')
[1]]
elif result[i][key] == '{}':
assert result2[i][key] is None
else:
assert result[i][key] == result2[i][key]
class TestSQLiteStorage(FlaskTrackUsageTestCase):
def _create_storage(self):
engine = sql.create_engine("sqlite://")
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(
engine=engine,
metadata=metadata,
table_name=self.given_table_name
)
metadata.create_all()
def tearDown(self):
meta = sql.MetaData()
meta.reflect(bind=self.storage._eng)
for table in reversed(meta.sorted_tables):
self.storage._eng.execute(table.delete())
def setUp(self):
self.given_table_name = 'my_usage'
FlaskTrackUsageTestCase.setUp(self)
self.blueprint = Blueprint('blueprint', __name__)
@self.blueprint.route('/blueprint')
def blueprint():
return "blueprint"
self.app.register_blueprint(self.blueprint)
self._create_storage()
self.track_usage = TrackUsage(self.app, self.storage)
self.track_usage.include_blueprint(self.blueprint)
def test_table_name(self):
meta = sql.MetaData()
meta.reflect(bind=self.storage._eng)
print(self.given_table_name, list(meta.tables.keys())[0])
self.assertIn(self.given_table_name, meta.tables.keys())
def test_storage_data_basic(self):
self.client.get('/')
con = self.storage._eng.connect()
s = sql.select([self.storage.track_table])
result = con.execute(s).fetchone()
#assert result[0] == 1 # first row
assert result[1] == u'http://localhost/'
assert result[2] is None
assert result[3] is None
assert result[4] is None
assert result[5] is None
assert result[6] is None
assert result[8] == 200
self.assertTrue(result[9])
assert result[10] == None
assert result[11] == False
assert result[12] is None
assert result[13] == '/'
assert result[14].__class__ is float
assert type(result[15]) is datetime.datetime
def test_storage_data_blueprint(self):
self.client.get('/blueprint')
con = self.storage._eng.connect()
s = sql.select([self.storage.track_table])
result = con.execute(s).fetchone()
assert result[1] == u'http://localhost/blueprint'
assert result[2] is None
assert result[3] is None
assert result[4] is None
assert result[5] is None
assert result[6] == 'blueprint'
assert result[8] == 200
self.assertTrue(result[9])
assert result[10] is None
assert result[11] == False
assert result[12] is None
assert result[13] == '/blueprint'
assert result[14].__class__ is float
assert type(result[15]) is datetime.datetime
def test_storage__get_raw(self):
# First check no blueprint case get_usage is correct
self.client.get('/')
result = self.storage._get_raw()[0]
assert result[1] == u'http://localhost/'
assert result[2] is None
assert result[3] is None
assert result[4] is None
assert result[5] is None
assert result[6] is None
assert result[8] == 200
self.assertTrue(result[9])
assert result[10] is None
assert result[11] == False
assert result[12] is None
assert result[13] == '/'
assert result[14].__class__ is float
assert type(result[15]) is datetime.datetime
# Next check with blueprint the get_usage is correct
self.client.get('/blueprint')
rows = self.storage._get_raw()
print(rows[1])
result = rows[1]# if rows[0][6] is None else rows[0]
#assert result[0] == 2 # first row
assert result[1] == u'http://localhost/blueprint'
assert result[2] is None
assert result[3] is None
assert result[4] is None
assert result[5] is None
assert result[6] == 'blueprint'
assert result[8] == 200
self.assertTrue(result[9])
assert result[10] is None
assert result[11] == False
assert result[12] is None
assert result[13] == '/blueprint'
assert result[14].__class__ is float
assert type(result[15]) is datetime.datetime
# third get
self.client.get('/')
# Limit tests
assert len(self.storage._get_raw()) == 3
assert len(self.storage._get_raw(limit=2)) == 2
assert len(self.storage._get_raw(limit=1)) == 1
# timing tests
# give a 5 second lag since datetime stored is second precision
now = datetime.datetime.utcnow() + datetime.timedelta(0, 5)
assert len(self.storage._get_raw(start_date=now)) == 0
assert len(self.storage._get_raw(end_date=now)) == 3
assert len(self.storage._get_raw(end_date=now, limit=2)) == 2
def test_storage__get_usage(self):
self.client.get('/')
result = self.storage._get_raw()[0]
result2 = self.storage._get_usage()[0]
#assert result[0] == 1 # first row
assert result[1] == result2['url']
assert result[2] == result2['user_agent']['browser']
assert result[3] == result2['user_agent']['language']
assert result[4] == result2['user_agent']['platform']
assert result[5] == result2['user_agent']['version']
assert result[6] == result2['blueprint']
assert result[8] == result2['status']
assert result[9] == result2['remote_addr']
assert result[10] == result2['xforwardedfor']
assert result[11] == result2['authorization']
assert result[12] == result2['ip_info']
assert result[13] == result2['path']
assert result[14] == result2['speed']
assert result[15] == result2['date']
assert result[16] == result2['username']
track_var = result[17] if result[17] != '{}' else None
assert track_var == result2['track_var']
def test_storage_get_usage(self):
self.client.get('/')
result = self.storage._get_raw()[0]
result2 = self.storage.get_usage()[0]
#assert result[0] == 1 # first row
assert result[1] == result2['url']
assert result[2] == result2['user_agent']['browser']
assert result[3] == result2['user_agent']['language']
assert result[4] == result2['user_agent']['platform']
assert result[5] == result2['user_agent']['version']
assert result[6] == result2['blueprint']
assert result[8] == result2['status']
assert result[9] == result2['remote_addr']
assert result[10] == result2['xforwardedfor']
assert result[11] == result2['authorization']
assert result[12] == result2['ip_info']
assert result[13] == result2['path']
assert result[14] == result2['speed']
assert result[15] == result2['date']
assert result[16] == result2['username']
track_var = result[17] if result[17] != '{}' else None
assert track_var == result2['track_var']
def test_storage_get_usage_pagination(self):
# test pagination
for i in range(100):
self.client.get('/')
limit = 10
num_pages = 10
for page in range(1, num_pages + 1):
result = self.storage._get_usage(limit=limit, page=page)
assert len(result) == limit
# actual api test
result = self.storage._get_raw(limit=100) # raw data
result2 = self.storage.get_usage(limit=100) # dict data
for i in range(100):
assert result[i][1] == result2[i]['url']
assert result[i][2] == result2[i]['user_agent']['browser']
assert result[i][3] == result2[i]['user_agent']['language']
assert result[i][4] == result2[i]['user_agent']['platform']
assert result[i][5] == result2[i]['user_agent']['version']
assert result[i][6] == result2[i]['blueprint']
assert result[i][8] == result2[i]['status']
assert result[i][9] == result2[i]['remote_addr']
assert result[i][10] == result2[i]['xforwardedfor']
assert result[i][11] == result2[i]['authorization']
assert result[i][12] == result2[i]['ip_info']
assert result[i][13] == result2[i]['path']
assert result[i][14] == result2[i]['speed']
assert result[i][15] == result2[i]['date']
assert result[i][16] == result2[i]['username']
track_var = result[i][17] if result[i][17] != '{}' else None
assert track_var == result2[i]['track_var']
def create_app():
app = Flask(__name__)
# Load config from ENV is set, default otherwise.
app.config.from_object(os.getenv('FLASK_SETTINGS', 'config.Config'))
# Configuring database.
# Causes significant overhead if True.
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# Tracks cookies - used for unique visitor count
app.config['TRACK_USAGE_COOKIE'] = True
db.init_app(app)
talisman.init_app(app,
content_security_policy={
'default-src':
'\'self\'',
'img-src': [
'*',
'data: https:',
],
'font-src':
'*',
'script-src': [
'\'self\'',
'\'unsafe-inline\'',
'maxcdn.bootstrapcdn.com',
'cdnjs.cloudflare.com',
'ajax.googleapis.com',
'kit.fontawesome.com',
'cdn.quilljs.com',
],
'style-src': [
'\'self\'',
'\'unsafe-inline\'',
'maxcdn.bootstrapcdn.com',
'kit-free.fontawesome.com',
'cdn.quilljs.com',
],
})
bcrypt.init_app(app)
login_manager.init_app(app)
login_manager.login_view = 'users.login'
#mail.init_app(app)
# We need the app's context to create the db related to it.
from models import init_db, User
with app.app_context():
init_db()
# TrackUsage Setup
pstore = SQLStorage(db=db)
t = TrackUsage(app, [pstore])
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
from drug_chart.routes import drug_chart
from users.routes import users
from main.routes import main
from announcements.routes import announcements
from faq.routes import faq
from about.routes import about
from content.routes import content
from dashboard.routes import dashboard
from quiz.routes import quiz
blueprints = [
drug_chart, users, main, faq, about, announcements, content, dashboard,
quiz
]
for blueprint in blueprints:
app.register_blueprint(blueprint)
t.include_blueprint(blueprint)
@app.errorhandler(404)
def page_not_found(error):
return render_template('404.html', title='404'), 404
return app
class TestMySQLStorageSummary(FlaskTrackUsageTestCase):
def _create_storage(self):
engine = sql.create_engine(SQLALCHEMY_DATABASE_URI)
metadata = sql.MetaData(bind=engine)
self.storage = SQLStorage(
engine=engine,
metadata=metadata,
table_name=self.given_table_name,
hooks=[sumUrl, sumRemote, sumUserAgent, sumLanguage, sumServer])
# metadata.create_all()
def setUp(self):
self.given_table_name = 'my_usage'
FlaskTrackUsageTestCase.setUp(self)
self.blueprint = Blueprint('blueprint', __name__)
@self.blueprint.route('/blueprint')
def blueprint():
return "blueprint"
self.app.register_blueprint(self.blueprint)
self._create_storage()
self.fake_time = datetime.datetime(
2018, 4, 15, 9, 45, 12) # Apr 15, 2018 at 9:45:12 AM UTC
self.fake_hour = datetime.datetime(2018, 4, 15, 9, 0,
0) # Apr 15, 2018 at 9:00:00 AM UTC
self.fake_day = datetime.datetime(2018, 4, 15, 0, 0,
0) # Apr 15, 2018 at 0:00:00 AM UTC
self.fake_month = datetime.datetime(
2018, 4, 1, 0, 0, 0) # Apr 1, 2018 at 0:00:00 AM UTC
self.track_usage = TrackUsage(self.app,
self.storage,
_fake_time=self.fake_time)
self.track_usage.include_blueprint(self.blueprint)
def tearDown(self):
meta = sql.MetaData()
meta.reflect(bind=self.storage._eng)
for table in reversed(meta.sorted_tables):
table.drop(self.storage._eng)
def test_table_names(self):
meta = sql.MetaData()
meta.reflect(bind=self.storage._eng)
self.assertIn('my_usage_language_hourly', meta.tables.keys())
self.assertIn('my_usage_remote_monthly', meta.tables.keys())
self.assertIn('my_usage_language_monthly', meta.tables.keys())
self.assertIn('my_usage_url_monthly', meta.tables.keys())
self.assertIn('my_usage_useragent_hourly', meta.tables.keys())
self.assertIn('my_usage_server_hourly', meta.tables.keys())
self.assertIn('my_usage_remote_hourly', meta.tables.keys())
self.assertIn('my_usage_remote_daily', meta.tables.keys())
self.assertIn('my_usage_language_daily', meta.tables.keys())
self.assertIn('my_usage_url_hourly', meta.tables.keys())
self.assertIn('my_usage_useragent_monthly', meta.tables.keys())
self.assertIn('my_usage_useragent_daily', meta.tables.keys())
self.assertIn('my_usage_url_daily', meta.tables.keys())
self.assertIn('my_usage_server_daily', meta.tables.keys())
self.assertIn('my_usage_server_monthly', meta.tables.keys())
def test_basic_suite(self):
self.client.get('/') # call 3 times to make sure upsert works
self.client.get('/')
self.client.get('/')
con = self.storage._eng.connect()
# Test the get sum
results = self.storage.get_sum('sumUrl')
self.assertIn('url_hourly', results.keys())
self.assertIn('url_daily', results.keys())
self.assertIn('url_monthly', results.keys())
assert len(results['url_hourly']) == 1
assert len(results['url_daily']) == 1
assert len(results['url_monthly']) == 1
# URL
table = self.storage.sum_tables["url_hourly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_hour)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_hour
assert result[1] == u'http://localhost/'
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["url_daily"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_day)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_day
assert result[1] == u'http://localhost/'
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["url_monthly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_month)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_month
assert result[1] == u'http://localhost/'
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
# REMOTE IP
table = self.storage.sum_tables["remote_hourly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_hour)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_hour
assert result[1] == "127.0.0.1"
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["remote_daily"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_day)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_day
assert result[1] == "127.0.0.1"
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["remote_monthly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_month)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_month
assert result[1] == "127.0.0.1"
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
# USER AGENT
table = self.storage.sum_tables["useragent_hourly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_hour)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_hour
assert result[1].startswith("werkzeug/")
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["useragent_daily"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_day)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_day
assert result[1].startswith("werkzeug/")
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["useragent_monthly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_month)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_month
assert result[1].startswith("werkzeug/")
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
# LANGUAGE
table = self.storage.sum_tables["language_hourly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_hour)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_hour
assert result[
1] is None # the werkzeug test client does not have a language
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["language_daily"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_day)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_day
assert result[1] is None
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["language_monthly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_month)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_month
assert result[1] is None
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
# WHOLE SERVER
table = self.storage.sum_tables["server_hourly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_hour)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_hour
assert result[1] == self.app.name
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["server_daily"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_day)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_day
assert result[1] == self.app.name
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
table = self.storage.sum_tables["server_monthly"]
s = sql \
.select([table]) \
.where(table.c.date==self.fake_month)
result = con.execute(s).fetchone()
assert result is not None
assert result[0] == self.fake_month
assert result[1] == self.app.name
assert result[2] == '{}'
assert result[3] == 3
assert result[4] == 18
