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 setUp(self): """ Set up an app to test with. """ FlaskTrackUsageTestCase.setUp(self) self.storage = MongoEngineStorage(hooks=[ sumUrl, sumRemote, sumUserAgent, sumLanguage, sumServer ]) self.track_usage = TrackUsage(self.app, self.storage) # Clean out the summary UsageTrackerSumUrlHourly.drop_collection() UsageTrackerSumUrlDaily.drop_collection() UsageTrackerSumUrlMonthly.drop_collection() UsageTrackerSumRemoteHourly.drop_collection() UsageTrackerSumRemoteDaily.drop_collection() UsageTrackerSumRemoteMonthly.drop_collection() UsageTrackerSumUserAgentHourly.drop_collection() UsageTrackerSumUserAgentDaily.drop_collection() UsageTrackerSumUserAgentMonthly.drop_collection() UsageTrackerSumLanguageHourly.drop_collection() UsageTrackerSumLanguageDaily.drop_collection() UsageTrackerSumLanguageMonthly.drop_collection() UsageTrackerSumServerHourly.drop_collection() UsageTrackerSumServerDaily.drop_collection() UsageTrackerSumServerMonthly.drop_collection() # trigger one timed summary self.now = datetime.datetime.utcnow() self.hour = self.now.replace(minute=0, second=0, microsecond=0) self.day = self.now.replace(hour=0, minute=0, second=0, microsecond=0) self.month = self.now.replace(day=1, hour=0, minute=0, second=0, microsecond=0) self.client.get('/')
def test_neither_include_nor_exclude(self): """ Verify that we fail when we don't state include or exclude. """ self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = '' with self.assertRaises(NotImplementedError): TrackUsage(self.app, self.storage)
def setUp(self): """ Set up an app to test with. """ FlaskTrackUsageTestCase.setUp(self) self.storage = TestStorage() self.track_usage = TrackUsage(self.app, self.storage)
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(Config) # app.redis = Redis.from_url(app.config['REDIS_URL']) # app.task_queue = rq.Queue(connection=app.redis) db.init_app(app) t = TrackUsage( app, [MongoStorage('PersonalWebsite', 'tracking', Config.MONGO_URI)]) from website.main.routes import main from website.jobs.routes import jobs from website.analytics.routes import analytics_bp app.register_blueprint(main) app.register_blueprint(jobs) app.register_blueprint(analytics_bp) t.include_blueprint(main) return app
def setUp(self): """ Set up an app to test with. """ FlaskTrackUsageTestCase.setUp(self) self.storage = MongoEngineStorage() # Clean out the storage self.storage.collection.drop_collection() self.track_usage = TrackUsage(self.app, self.storage)
def setUp(self): """ Set up an app to test with. """ FlaskTrackUsageTestCase.setUp(self) self.storage = MongoStorage(database=DB, collection=COLL_NAME) # Clean out the storage self.storage.collection.drop() self.track_usage = TrackUsage(self.app, self.storage)
def setUp(self): """ Set up an app to test with. """ FlaskTrackUsageTestCase.setUp(self) self.storage = MongoPiggybackStorage(collection=COLLECTION) # Clean out the storage self.storage.collection.drop() self.track_usage = TrackUsage(self.app, self.storage)
def test_late_neither_include_nor_exclude(self): """ Make sure that if someone attempts to change the type to something unsupported we fail """ self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include' self.track_usage = TrackUsage(self.app, self.storage) self.track_usage._type = '' with self.assertRaises(NotImplementedError): self.client.get('/')
def setUp(self): """ Set up an app to test with. """ FlaskTrackUsageTestCase.setUp(self) # self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include' self.storage = RedisStorage() # Clean out the storage # self.storage.collection.drop() self.track_usage = TrackUsage(self.app, self.storage)
class TestFreeGeoIP(FlaskTrackUsageTestCaseGeoIP): 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' FlaskTrackUsageTestCaseGeoIP.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_storage_freegeoip(self): self.client.get('/') con = self.storage._eng.connect() s = sql.select([self.storage.track_table]) result = con.execute(s).fetchone() j = json.loads(result[12]) assert j["ipType"] == "Residential"
def test_exclude_blueprint(self): """ Verify that an entire blueprint can be excluded. """ self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude' tu = TrackUsage(self.app, self.storage) tu.exclude_blueprint(self.blueprint) # There should be 2 excluded views, 0 included views assert len(tu._include_views) == 0 assert len(tu._exclude_views) == 2 # Index should store something self.client.get('/') assert type(self.storage.get()) is dict # Both pages should not store anything for page in ('/included', '/excluded'): self.client.get(page) with self.assertRaises(IndexError): self.storage.get()
def test_include_blueprint(self): """ Verify that an entire blueprint can be included. """ self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include' tu = TrackUsage(self.app, self.storage) tu.include_blueprint(self.blueprint) # There should be 2 included views, no excluded views assert len(tu._include_views) == 2 assert len(tu._exclude_views) == 0 # Both paged should store for page in ('/included', '/excluded'): self.client.get(page) assert type(self.storage.get()) is dict # But the index (outside of the blueprint) should not self.client.get('/') with self.assertRaises(IndexError): self.storage.get()
def test_exclude_blueprint(self): """ Verify that an entire blueprint can be excluded. """ self.app.config[ 'TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude' tu = TrackUsage(self.app, self.storage) tu.exclude_blueprint(self.blueprint) # There should be 2 excluded views, 0 included views assert len(tu._include_views) == 0 assert len(tu._exclude_views) == 2 # Index should store something self.client.get('/') assert type(self.storage.get()) is dict # Both pages should not store anything for page in ('/included', '/excluded'): self.client.get(page) with self.assertRaises(IndexError): self.storage.get()
def test_include_blueprint(self): """ Verify that an entire blueprint can be included. """ self.app.config[ 'TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include' tu = TrackUsage(self.app, self.storage) tu.include_blueprint(self.blueprint) # There should be 2 included views, no excluded views assert len(tu._include_views) == 2 assert len(tu._exclude_views) == 0 # Both paged should store for page in ('/included', '/excluded'): self.client.get(page) assert type(self.storage.get()) is dict # But the index (outside of the blueprint) should not self.client.get('/') with self.assertRaises(IndexError): self.storage.get()
class TestFreeGeoIP(FlaskTrackUsageTestCaseGeoIP): 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' FlaskTrackUsageTestCaseGeoIP.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_storage_freegeoip(self): self.client.get('/') con = self.storage._eng.connect() s = sql.select([self.storage.track_table]) result = con.execute(s).fetchone() j = json.loads(result[12]) assert j["ipType"] == "Residential"
def test_raw_blueprint(self): """ Verify that raw blueprints don't get modified. """ self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include' tu = TrackUsage(self.app, self.storage) # There should be no included/excluded views assert len(tu._include_views) == 0 assert len(tu._exclude_views) == 0 # There should be no storing of data at all for page in ('/', '/included', '/excluded'): self.client.get(page) with self.assertRaises(IndexError): self.storage.get()
def test_include_type(self): """ Test that include only covers what is included. """ self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include' self.track_usage = TrackUsage(self.app, self.storage) @self.track_usage.include @self.app.route('/included') def included(): return "INCLUDED" # /includeds hould give results self.client.get('/included') assert type(self.storage.get()) is dict # / should not give results as it is not included self.client.get('/') with self.assertRaises(IndexError): self.storage.get()
def test_exclude_type(self): """ Test that exclude covers anything not excluded. """ self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude' self.track_usage = TrackUsage(self.app, self.storage) @self.track_usage.exclude @self.app.route('/excluded') def excluded(): return "INCLUDED" # / hould give results self.client.get('/') assert type(self.storage.get()) is dict # /excluded should not give results as it is excluded self.client.get('/excluded') with self.assertRaises(IndexError): self.storage.get()
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)
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)
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'] # Retrieve buyer number of home
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:]) try:
# ######################### me.connect("example_website") ######################### # # SETUP FLASK_TRACK_USAGE # ######################### app.config['TRACK_USAGE_USE_FREEGEOIP'] = False app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude' traffic_storage = MongoEngineStorage(hooks=[sumUrl, sumUserAgent]) t = TrackUsage(app, [traffic_storage]) ######################### # # PUBLIC ROUTES # ######################### @app.route('/') def index(): g.track_var["something"] = 99 return render_template('index.html') @app.route('/page1') def page_one(): g.track_var["something"] = 34
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 TestPostgreStorage(FlaskTrackUsageTestCase): 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() 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): self.storage._eng.execute(table.delete()) def test_table_names(self): meta = sql.MetaData() meta.reflect(bind=self.storage._eng) print(meta.tables.keys()) 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() # 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 18
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']
class TestPostgreStorage(FlaskTrackUsageTestCase): 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() 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): self.storage._eng.execute(table.delete()) def test_table_names(self): meta = sql.MetaData() meta.reflect(bind=self.storage._eng) print(meta.tables.keys()) 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() # 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 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] == 3 assert result[3] == 18
def setUp(self): """ Set up an app to test with. """ self.fake_time1 = datetime.datetime(2018, 4, 15, 8, 45, 12) # Apr 15, 2018 at 8:45:12 AM UTC self.fake_hour1 = datetime.datetime(2018, 4, 15, 8, 0, 0) # Apr 15, 2018 at 8:00:00 AM UTC self.fake_day1 = datetime.datetime(2018, 4, 15, 0, 0, 0) # Apr 15, 2018 at 0:00:00 AM UTC self.fake_month1 = datetime.datetime(2018, 4, 1, 0, 0, 0) # Apr 1, 2018 at 0:00:00 AM UTC self.fake_time2 = datetime.datetime(2018, 4, 15, 9, 45, 12) # Apr 15, 2018 at 9:45:12 AM UTC self.fake_hour2 = datetime.datetime(2018, 4, 15, 9, 0, 0) # Apr 15, 2018 at 9:00:00 AM UTC self.fake_day2 = datetime.datetime(2018, 4, 15, 0, 0, 0) # Apr 15, 2018 at 0:00:00 AM UTC self.fake_month2 = datetime.datetime(2018, 4, 1, 0, 0, 0) # Apr 1, 2018 at 0:00:00 AM UTC self.fake_time3 = datetime.datetime(2018, 4, 16, 9, 45, 12) # Apr 16, 2018 at 9:45:12 AM UTC self.fake_hour3 = datetime.datetime(2018, 4, 16, 9, 0, 0) # Apr 16, 2018 at 9:00:00 AM UTC self.fake_day3 = datetime.datetime(2018, 4, 16, 0, 0, 0) # Apr 16, 2018 at 0:00:00 AM UTC self.fake_month3 = datetime.datetime(2018, 4, 1, 0, 0, 0) # Apr 1, 2018 at 0:00:00 AM UTC self.fake_time4 = datetime.datetime(2018, 5, 10, 9, 45, 12) # May 10, 2018 at 9:45:12 AM UTC self.fake_hour4 = datetime.datetime(2018, 5, 10, 9, 0, 0) # May 10, 2018 at 9:00:00 AM UTC self.fake_day4 = datetime.datetime(2018, 5, 10, 0, 0, 0) # May 10, 2018 at 0:00:00 AM UTC self.fake_month4 = datetime.datetime(2018, 5, 1, 0, 0, 0) # May 1, 2018 at 0:00:00 AM UTC FlaskTrackUsageTestCase.setUp(self) self.storage = MongoEngineStorage(hooks=[ sumUrl, sumRemote, sumUserAgent, sumLanguage, sumServer ]) self.track_usage = TrackUsage( self.app, self.storage, _fake_time = self.fake_time1 ) # Clean out the summary UsageTrackerSumUrlHourly.drop_collection() UsageTrackerSumUrlDaily.drop_collection() UsageTrackerSumUrlMonthly.drop_collection() UsageTrackerSumRemoteHourly.drop_collection() UsageTrackerSumRemoteDaily.drop_collection() UsageTrackerSumRemoteMonthly.drop_collection() UsageTrackerSumUserAgentHourly.drop_collection() UsageTrackerSumUserAgentDaily.drop_collection() UsageTrackerSumUserAgentMonthly.drop_collection() UsageTrackerSumLanguageHourly.drop_collection() UsageTrackerSumLanguageDaily.drop_collection() UsageTrackerSumLanguageMonthly.drop_collection() UsageTrackerSumServerHourly.drop_collection() UsageTrackerSumServerDaily.drop_collection() UsageTrackerSumServerMonthly.drop_collection() # generate four entries at different times # self.client.get('/') self.track_usage._fake_time = self.fake_time2 self.client.get('/') self.track_usage._fake_time = self.fake_time3 self.client.get('/') self.track_usage._fake_time = self.fake_time4 self.client.get('/')
#!/usr/bin/env python # -*- coding: utf-8 -*- import json from flask import Flask from flask_track_usage import TrackUsage from flask_track_usage.storage.redis_db import RedisStorage from datetime import datetime app = Flask(__name__) redis = RedisStorage() track = TrackUsage(app, redis) @app.route('/') def index(): return "ok" @track.exclude @app.route('/usage') def usage(): now = datetime.now() yesterday = datetime.fromtimestamp(1421111101) # 2015-1-13 02:05:01 res = redis.get_usage(now, yesterday) # res = redis.get_usage() print res return json.dumps(res) app.config['PROPAGATE_EXCEPTIONS'] = True app.run(port=8081, use_reloader=True)
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']
from flask import Flask, g from pymongo import MongoClient from flask_track_usage import TrackUsage from flask_track_usage.summarization import sumUrl from flask_mongoengine import MongoEngine from flask_track_usage.storage.mongo import MongoEngineStorage app = Flask(__name__) # Set the configuration items manually for the example app.config['TRACK_USAGE_USE_FREEGEOIP'] = False # You can use a different instance of freegeoip like so # app.config.cgf['TRACK_USAGE_FREEGEOIP_ENDPOINT'] = 'http://extreme-ip-lookup.com/json/' app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include' app.config['MONGODB_SETTINGS'] = {'db': 'website'} mongo_db = MongoEngine(app) mstore = MongoEngineStorage(hooks=[sumUrl]) # Make an instance of the extension and put two writers t = TrackUsage(app, [mstore]) # dbs = list(db.usageTracking.find({})) # a= len(dbs) # print(dbs) # Run the application!
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)
import os from flask import Flask, render_template from flask_sqlalchemy import SQLAlchemy from flask_bcrypt import Bcrypt from flask_login import LoginManager from flask_track_usage import TrackUsage from flask_track_usage.storage.sql import SQLStorage from flask_talisman import Talisman # To force an SSL connection #from flask_mail import Mail db = SQLAlchemy() bcrypt = Bcrypt() talisman = Talisman() login_manager = LoginManager() t = TrackUsage() #mail = Mail() 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,
try: from flask import Flask, g from flask_track_usage import TrackUsage from flask_track_usage.storage.printer import PrintWriter from flask_track_usage.storage.output import OutputWriter except Exception as e: print("Some modules is missing:{}".format(e)) app = Flask(__name__) app.config['TRACK_USAGE_USE_FREEGEOIP'] = False app.config["TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS"] = "include" t = TrackUsage( app, [PrintWriter(), OutputWriter(transform=lambda s: "OUTPUT: " + str(s))]) @t.include @app.route("/") def index(): g.track_var["optional"] = "something" return "Hello" if __name__ == "__main__": app.run(debug=True)
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]