def client(): """ This function initialize a new DB for every test and creates the app. This function returns a tuple, the first element is a test client and the second is the app itself. Test client must be used for sending request and the app should be used for getting a context when, for example, we need to query the DB. I haven't found a more elegant way to do this.""" app = create_app() app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db_fd, app.config['DATABASE'] = tempfile.mkstemp() print(app.config['DATABASE']) app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE'] app.config['TESTING'] = True app.config[ 'WTF_CSRF_ENABLED'] = False # disable CSRF validation -> DO THIS ONLY DURING TESTS! client = app.test_client() db.create_all(app=app) db.init_app(app=app) #with app.app_context(): #db.engine.execute(_data_sql) with app.app_context(): q = db.session.query(User).filter(User.email == '*****@*****.**') user = q.first() if user is None: example = User() example.email = '*****@*****.**' example.is_admin = True example.set_password('admin') db.session.add(example) db.session.commit() yield client, app os.close(db_fd) os.unlink(app.config['DATABASE'])
def send_all_mail(): # pragma: no cover print('sending') global _APP # lazy init if _APP is None: from monolith.app import create_app app = create_app() db.init_app(app) else: app = _APP mail = Mail(app) mail.init_app(app=app) with app.app_context(): users = db.session.query(User).filter() for user in users: report = db.session.query(Report).filter( Report.runner_id == user.id).first() if report is not None and time( ) - report.timestamp >= report.choice_time: body = prepare_body(user, app) if body: msg = Message('Your BeepBeep Report', sender=app.config['MAIL_USERNAME'], recipients=[user.email]) msg.body = body mail.send(msg) report.set_timestamp() db.session.merge(report) db.session.commit()
def test_invalid_post_short_story(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app) with tested_app.test_client() as client: # login reply = login(client, '*****@*****.**', 'admin') assert b'Hi Admin!' in reply.data reply = client.get('/stories') assert b'Trial story of example admin user' in reply.data # post a new story roll = json.dumps( ["bird", "whale", "coffee", "bananas", "ladder", "glasses"]) reply = client.post('/stories', data=dict(text="short story", roll=roll), follow_redirects=True) self.assertEqual(reply.status_code, 200) assert b'The number of words of the story must greater or equal of the number of resulted faces.' in reply.data # check database entry q = db.session.query(Story).order_by(Story.id.desc()).first() self.assertNotEqual(q.text, "short story")
def test1(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app) with tested_app.test_client() as client: # login reply = login(client, '*****@*****.**', 'admin') assert b'Hi Admin!' in reply.data reply = client.get('/stories/filter') self.assertIn(b'Filter Stories', reply.data) # Filter correctly a time interval reply = client.post('/stories/filter', data=dict( init_date='2019-01-01', end_date='2019-12-01' ), follow_redirects=True) self.assertIn(b'Trial story of example', reply.data) # Filter wrongly a time interval (init_date > end_date) reply = client.post('/stories/filter', data=dict( init_date='2019-12-01', end_date='2019-01-01' ), follow_redirects=True) self.assertIn(b'Cant travel back in time', reply.data)
def test_roll(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app) with tested_app.test_client() as client: # login reply = login(client, '*****@*****.**', 'admin') self.assertEqual(reply.status_code, 200) # wrong dice number reply = client.get('/rolldice/12/basic') assert b'Error!' in reply.data # non-existing dice set reply = client.get('/rolldice/6/pippo') self.assertEqual(reply.status_code, 404) # correct roll reply = client.get('/rolldice/5/basic') self.assertEqual(reply.status_code, 200)
def test_story_retrieval(self): tested_app = create_app(debug=True) with tested_app.test_client() as client: reply = client.get('/stories/random', content_type='html/text', follow_redirects=True) self.assertIn('<div class="card text-center">', str(reply.data))
def test_getuser(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app) with tested_app.test_client() as client: with client.session_transaction() as session: user_base = User.query.first() # push in the users_table 3 users user_a = User() user_a.email = '*****@*****.**' user_a.set_password('test') user_b = User() user_b.email = '*****@*****.**' user_b.set_password('test') user_c = User() user_c.email = '*****@*****.**' user_c.set_password('test') db.session.add(user_a) db.session.add(user_b) db.session.add(user_c) db.session.commit() res = get_users() correct = [user_base, user_a, user_b, user_c] print(res) print(correct) self.assertEqual(res, correct)
def send_report(): global _APP # lazy init if _APP is None: from monolith.app import create_app app = create_app() db.init_app(app) else: app = _APP with app.app_context(): mail = Mail(app) q = db.session.query(User) # Check all users if they requested report for user in q: if user.email_frequency is None: continue # check report freq against the current time - in case worker dies the report would be send with proper freq # Opposed to when some counter would be used(the state of counyter would die with it) if int(time.time()) % user.email_frequency == 0: msg = Message('BeepBeep Email report', sender=os.environ['EMAIL_ID'], recipients=[user.email]) msg.body = "Report from strava" mail.send(msg)
def test_get_followed_list(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app) with tested_app.test_client() as client: with client.session_transaction() as session: # push in the users_table 3 users user_a = User() user_a.email = '*****@*****.**' user_a.set_password('test') user_b = User() user_b.email = '*****@*****.**' user_b.set_password('test') user_c = User() user_c.email = '*****@*****.**' user_c.set_password('test') user_d = User() user_d.email = '*****@*****.**' user_d.set_password('test') db.session.add(user_a) db.session.add(user_b) db.session.add(user_c) db.session.add(user_d) db.session.commit() # Get users ID user_a_id = User.query.filter_by( email=user_a.email).first().get_id() user_b_id = User.query.filter_by( email=user_b.email).first().get_id() user_c_id = User.query.filter_by( email=user_c.email).first().get_id() user_d_id = User.query.filter_by( email=user_d.email).first().get_id() with client.session_transaction() as session: follow_ab = _create_follow(user_a_id, user_b_id) follow_ac = _create_follow(user_a_id, user_c_id) follow_ad = _create_follow(user_a_id, user_d_id) follow_bc = _create_follow(user_b_id, user_c_id) db.session.add(follow_ab) db.session.add(follow_ac) db.session.add(follow_ad) db.session.add(follow_bc) db.session.commit() res = get_followed_list(user_a_id) correct = [user_b_id, user_c_id, user_d_id] self.assertEqual(res, correct)
def test_send_email(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app)
def client(): app = create_app(tests=True) app.config["TESTING"] = True app.config["WTF_CSRF_ENABLED"] = False app.config["DEBUG"] = True ctx = app.app_context() ctx.push() with app.test_client() as client: yield client
def fetch_all_runs(): global _APP # lazy init if _APP is None: from monolith.app import create_app app = create_app() db.init_app(app) else: app = _APP return runs_fetched
def do_task(): global _APP # lazy init if _APP is None: from monolith.app import create_app app = create_app() db.init_app(app) else: app = _APP return []
def app(): db_fd, db_path = tempfile.mkstemp() db_url = 'sqlite:///' + db_path app = create_app(test=True, database=db_url, test_telegram=True) yield app app.config['TELEGRAM_UPDATER'].stop() os.close(db_fd) os.unlink(db_path)
def create_context(): global _APP # lazy init print(_APP) #for testing shows what kind of app we use if _APP is None: from monolith.app import create_app app = create_app() db.init_app(app) _APP = app else: app = _APP return app
def test1(self): global _app tested_app = create_app(debug=True) _app = tested_app with tested_app.test_client() as client: with client.session_transaction() as sess: db.drop_all() db.create_all() with tested_app.test_client() as client: # Create user resp = client.post('/signup', data=dict(firstname="admin_firstname", lastname="admin_lastname", email="*****@*****.**", dateofbirth=1994, password="******"), follow_redirects=True) assert b'Index Page' in resp.data # login reply = login(client, '*****@*****.**', 'admin') assert b'Hi admin_firstname!' in reply.data # post a new story roll = json.dumps(["bike", "tulip", "happy", "cat", "ladder", "rain"]) reply = client.post('/stories', data=dict(text="bike tulip happy cat ladder rain", roll=roll), follow_redirects=True) assert b'bike tulip happy cat ladder rain' in reply.data reply = client.get('/stories') assert b'bike tulip happy cat ladder rain' in reply.data # add reaction to a story reply = client.get('/stories/reaction/1/1') print(reply.data) assert b'Reaction created' in reply.data # add same reaction to a story - delete that reaction reply = client.get('/stories/reaction/1/1') assert b'Reaction removed!' in reply.data # add different reaction to a story reply = client.get('/stories/reaction/1/2') assert b'Reaction created' in reply.data # change the reaction to a story reply = client.get('/stories/reaction/1/1') assert b'Reaction changed!' in reply.data # add reaction to non-existing story reply = client.get('/stories/reaction/3/1') assert b'Story not exists!' in reply.data
def test2(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app # create 100 Stories restart_db_tables(db, tested_app) with tested_app.test_client() as client: # login reply = login(client, '*****@*****.**', 'admin') assert b'Hi Admin!' in reply.data
def test_delete_story_negative(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app) with tested_app.test_client() as client: # login reply = login(client, '*****@*****.**', 'admin') self.assertEqual(reply.status_code, 200) users = User.query.all() self.assertEqual(len(users), 1) # add reaction to a story reply = client.get('/stories/reaction/1/1') self.assertEqual(reply.status_code, 200) reply = client.post('stories/2/remove/stories', follow_redirects=True) self.assertEqual(reply.status_code, 404) story = db.session.query(Story).filter_by(id=1).first() self.assertNotEqual(story, None) reactions = Reaction.query.filter_by(story_id=1).all() self.assertEqual(len(reactions), 1) stories = Story.query.filter_by(id=1).all() self.assertEqual(len(stories), 1) users = User.query.all() self.assertEqual(len(users), 1) reply = client.post('stories/1/remove/stories', follow_redirects=True) self.assertEqual(reply.status_code, 200) assert b'The story has been canceled.' in reply.data reactions = Reaction.query.filter_by(story_id=1).all() self.assertEqual(len(reactions), 0) # logout reply = logout(client) self.assertEqual(reply.status_code, 200)
def test_app(): app = create_app() app.config[ 'WTF_CSRF_ENABLED'] = False #this has been disabled to allows testing of forms temp_db, app.config['DATABASE'] = tempfile.mkstemp() app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE'] db.create_all(app=app) db.init_app(app=app) yield app, app.test_client() os.close(temp_db)
def like_task(): global _APP # lazy init if _APP is None: print("App not yet initialized") _APP = create_app() db.init_app(_APP) with _APP.app_context(): q = db.engine.execute( "SELECT story_id, reaction_type_id, reaction_caption, COUNT(*) AS count, marked " "FROM reaction r " "JOIN reaction_catalogue rc on r.reaction_type_id = rc.reaction_id " "JOIN story s on r.story_id = s.id " "WHERE marked=0 OR marked=2 " "GROUP BY story_id, reaction_type_id, marked " "ORDER BY story_id, reaction_type_id, marked").fetchall() print("Analyzing {} reactions: \n".format(len(q))) for r in q: print("Story {}: {} {}(s) marked to {}".format( r.story_id, r.count, r.reaction_caption, r.marked)) counter_row = Counter.query.filter( and_(Counter.reaction_type_id == r.reaction_type_id, Counter.story_id == r['story_id'])).first() if r.marked == 0: # INCREASE COUNTER if counter_row is None: # non-existing counter # Create counter and set it new_counter = Counter() new_counter.reaction_type_id = r.reaction_type_id new_counter.story_id = r.story_id new_counter.counter = r.count db.session.add(new_counter) else: # existing counter counter_row.counter = counter_row.counter + r.count else: # DECREASE COUNTER counter_row.counter = counter_row.counter - r.count # Delete all the rows with marked = 2 Reaction.query.filter(Reaction.marked == 2).delete() # Update all the rows with marked = 1 Reaction.query.filter(Reaction.marked == 0).update( {Reaction.marked: 1}) db.session.commit()
def test_reduce_list(self): tested_app = create_app(debug=True) with tested_app.test_client() as client: with client.session_transaction(): user_stories = db.session.query(User, Story) \ .join(Story) \ .order_by(desc(Story.id)) user_stories = reduce_list(user_stories) users = db.session.query(User) for user in users: filtered = list( filter(lambda x: x[0].id == user.id, user_stories)) print(user, filtered) self.assertTrue(len(filtered) in [0, 1])
def app(): ''' Builds and configures a new app instance for each test, using the test flag and a temporary fresh database. Automatically manages the temporary files. Can be overridden locally to pass different flags to the app instance, see test_unitStories for reference. ''' db_fd, db_path = tempfile.mkstemp() db_url = 'sqlite:///' + db_path app = create_app(test=True, database=db_url) yield app os.close(db_fd) os.unlink(db_path)
def update_reactions(story_id): global _APP if _APP is None: from monolith.app import create_app app = create_app() # db.init_app(app) else: app = _APP with app.app_context(): q = Story.query.filter_by(id=story_id).first() # count the likes, dislikes # use the first column for efficiency # [https://stackoverflow.com/questions/14754994/why-is-sqlalchemy-count-much-slower-than-the-raw-query] num_likes = db.session.query(Reaction.story_id).filter_by( story_id=story_id, type=1).count() num_dislikes = db.session.query(Reaction.story_id).filter_by( story_id=story_id, type=2).count() # update likes and dislikes counters q.likes = num_likes q.dislikes = num_dislikes db.session.commit()
def fetch_all_runs(): global _APP # lazy init if _APP is None: from monolith.app import create_app app = create_app() db.init_app(app) else: app = _APP runs_fetched = {} with app.app_context(): q = db.session.query(User) for user in q: if user.strava_token is None: continue print('Fetching Strava for %s' % user.email) runs_fetched[user.id] = fetch_runs(user) return runs_fetched
def fetch_all_groups(): global _APP # lazy init if _APP is None: from monolith.app import create_app app = create_app() db.init_app(app) else: app = _APP groups_fetched = {} with app.app_context(): q = db.session.query(User) for user in q: if user.gitlab_token is None: continue print('Fetching Gitlab Groups for %s' % user.email) groups_fetched[user.id] = fetch_groups(user) return groups_fetched
def test_invalid_post_too_long_story(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app) with tested_app.test_client() as client: # login reply = login(client, '*****@*****.**', 'admin') assert b'Hi Admin!' in reply.data reply = client.get('/stories') assert b'Trial story of example admin user' in reply.data # post a new story roll = json.dumps( ["bird", "whale", "coffee", "bananas", "ladder", "glasses"]) text = "" for i in range(0, 2000): text = text + " a" print('ERROR 2', file=sys.stderr) reply = client.post('/stories', data=dict(text=text, roll=roll), follow_redirects=True) self.assertEqual(reply.status_code, 200) assert b'The story is too long' in reply.data # check database entry q = db.session.query(Story).order_by(Story.id.desc()).first() self.assertNotEqual(q.text, text)
def test_email_sender(self): global _app if _app is None: tested_app = create_app(debug=True) _app = tested_app else: tested_app = _app restart_db_tables(db, tested_app) with tested_app.test_client() as client: with client.session_transaction() as session: example2 = User() example2.firstname = 'Daniele' example2.lastname = 'Arioli' example2.email = '*****@*****.**' example2.dateofbirth = datetime(2020, 10, 5) example2.is_admin = True example2.set_password('admin') db.session.add(example2) db.session.commit() self.assertTrue(send_emails())
import datetime import random import unittest import json from flask import request, jsonify from monolith.app import create_app from monolith.classes.Wall import Wall from monolith.database import db, User, Story from monolith.tests.test_stories_reactions import login test_app = create_app(debug=True) test_app.app_context().push() class WallTestCase(unittest.TestCase): def test_json_wall(self): app = test_app.test_client() with app.session_transaction() as sess: db.drop_all() db.create_all() q = db.session.query(User).filter(User.email == '*****@*****.**') user = q.first() if user is None: example = User() example.firstname = 'userwall' example.lastname = 'theWall' example.email = '*****@*****.**' example.dateofbirth = datetime.datetime(2020, 10, 5) example.is_admin = True
def getTester(self): application = app.create_app() tester = application.test_client(self) return tester
def setUpClass(self): self.app = create_app() self.app.test_client_class = FlaskClient