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