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 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_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]
