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