def browser(): client = None options = webdriver.ChromeOptions() options.add_argument('headless') try: client = webdriver.Chrome(options=options) except Exception: pass if client: app_context = app.app_context() app_context.push() db_fd, db_path = tempfile.mkstemp() db_url = 'sqlite:///' + db_path app.config['SQLALCHEMY_DATABASE_URI'] = db_url app.config["SQLALCHEMY_ECHO"] = False app.config['TESTING'] = True server = Process(target=app.run) server.start() time.sleep(1) with app.app_context(): db.drop_all() db.create_all() bind_factories(db.session) client.get('http://127.0.0.1:5000/') # time.sleep(2) yield client server.terminate() client.close() os.close(db_fd) os.unlink(db_path) app_context.pop()
def setUpClass(cls): app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'postgresql://{user}:{password}@{host}/{database}'.format( **config) app.app_context().push() db.init_app(app) cls.app = app.test_client()
def test_create_ticket(self): with app.app_context(): title = 'this is the title' content = 'this is some content' # get data for forms submission priority = FlicketPriority.query.first() category = FlicketCategory.query.first() user = CreateUser() self.login(username=user.username, password=user.password) _url = url_for('flicket_bp.ticket_create') result = self.client.post(_url, buffered=True, content_type='multipart/form-data', data={ 'title': title, 'content': content, 'priority': str(priority.id), 'category': str(category.id), 'file[]': '', 'submit': 'Submit' }, follow_redirects=True) self.assertIn(b'new ticket created', result.data.lower()) self.logout()
def initDB(): with app.app_context(): db = getDB() with app.open_resource(app.config['SCHEMA'], mode='r') as f: db.cursor().executescript(f.read()) print "Initialized Database." db.commit()
def UpgradeDB(): """ Mise à jour de la DB """ with app.app_context(): app.logger.info("Migration de la base de donnees...") try: flask_migrate.migrate(directory=REP_MIGRATIONS) app.logger.info("Migrate - Migration ok.") except SystemExit as e: app.logger.info("SystemQuit -> Erreur dans migration > migrate") app.logger.info(traceback.format_exc()) except Exception, err: app.logger.info("Erreur dans migration > migrate.") app.logger.info(err) app.logger.info("Upgrade de la base de donnees...") try: flask_migrate.upgrade(directory=REP_MIGRATIONS) app.logger.info("Migrate - Upgrade ok.") except SystemExit as e: app.logger.info("SystemQuit -> Erreur dans migration > upgrade.") app.logger.info(traceback.format_exc()) except Exception, err: app.logger.info("Erreur dans migration > upgrade.") app.logger.info(err) # Si la revision n'existe pas if "Can't locate revision" in str(err): app.logger.info("Suppression table alembic_version...") result = db.session.execute( "DROP TABLE IF EXISTS alembic_version;") app.logger.info("Suppression du repertoire migrations...") shutil.rmtree(REP_MIGRATIONS) flask_migrate.init(directory=REP_MIGRATIONS) flask_migrate.migrate()
def generate_qrcode(inputText): with app.app_context(): img = qrcode.make(inputText) img.save('qrcode.png') album = None image_path = 'qrcode.png' clientId = 'F5a0da0ee22b6b9' # Please get your own ClientId from imgur url = "https://api.imgur.com/3/image" payload = {'image': open(image_path, 'rb').read(), 'type': 'file'} headers = { 'authorization': 'Client-ID ' + clientId } # notice the space after Client-ID, concat response = requests.request( "POST", url, data=payload, headers=headers) # post image anonymously to imgur # return json.dumps(response.text) temp_obj = json.loads( response.text) # json encode response again since it's a string app.logger.info(temp_obj) responseURL = temp_obj["data"]["link"] return responseURL
def post_blog(self, db, json): with app.app_context(): blogger = json.get('blogger') url = json.get('url') title = json.get('title') rec = Recommendation() blog = Blog(url=url, title=title, blogger=blogger, recommendation=rec) db.session.add(rec) db.session.add(blog) db.session.commit() db.session.refresh(rec) if json.get('tags'): for tag in json.get('tags'): tag_in_database = Tag.query.filter(Tag.name == tag).first() if tag_in_database == None: self.add_tag(self, rec, db, tag) else: self.add_tag_recommendation( self, rec, db, tag_in_database) return jsonify(blog.serialize)
def test_userGet(self): with app.app_context(): """ Getting the mock data of the by passing the username as a parameter to the get. """ valid_code = routes.UserId().get("James") # This form is preferred over getting key value pairs from dict because it makes ID fetching easier. valid_user = User.objects().first() self.assertEqual(200, valid_code.status_code) self.assertEqual(models.ObjectId("6062dabdbbb2c3f109a049e9"), valid_user._id) self.assertEqual("James", valid_user.username) self.assertEqual("123", valid_user.password) """ Retrieving status code and user data """ invalid_code1 = routes.UserId().get("Sam") print( f"GetOne - Expecting error message, getting: '{invalid_code1.json['error']}'" ) self.assertEqual(400, invalid_code1.status_code) """ Testing for a user which does not exist """ invalid_code2 = routes.UserId().get("jAmEs") print( f"GetOne - Expecting error message, getting: '{invalid_code2.json['error']}'" ) self.assertEqual(400, invalid_code2.status_code) """
def post_book(self, db, json): with app.app_context(): title = json.get('title') author = json.get('author') isbn = json.get('isbn') isRead = 0 rec = Recommendation() book = Book(title=title, author=author, isbn=isbn, isRead=isRead, recommendation=rec) db.session.add(rec) db.session.add(book) db.session.commit() db.session.refresh(rec) if json.get('tags'): for tag in json.get('tags'): tag_in_database = Tag.query.filter(Tag.name == tag).first() if tag_in_database == None: self.add_tag(self, rec, db, tag) else: self.add_tag_recommendation( self, rec, db, tag_in_database) return jsonify(book.serialize)
def test_cache_control(self): with app.app_context(): response = self.get_response() self.assertEqual(response.headers['Cache-Control'], 'private, max-age=%s' % 3600) self.assertTrue('Expires' in response.headers) self.assertTrue('Last-Modified' in response.headers)
def UpgradeDB(): """ Mise à jour de la DB """ with app.app_context(): app.logger.info("Migration de la base de donnees...") try: flask_migrate.migrate(directory=REP_MIGRATIONS) except Exception, err: if "Path doesn't exist" in str(err): app.logger.info( "Repertoire Migrations manquant -> Initialisation de flask_migrate maintenant..." ) flask_migrate.init(directory=REP_MIGRATIONS) flask_migrate.migrate() app.logger.info("Migration ok.") app.logger.info("Upgrade de la base de donnees...") try: flask_migrate.upgrade(directory=REP_MIGRATIONS) app.logger.info("Upgrade ok.") except Exception, err: app.logger.info("Erreur Upgrade.") app.logger.info(err) # Si la revision n'existe pas if "Can't locate revision" in str(err): app.logger.info("Suppression table alembic_version...") result = db.session.execute( "DROP TABLE IF EXISTS alembic_version;") app.logger.info("Suppression du repertoire migrations...") shutil.rmtree(REP_MIGRATIONS) flask_migrate.init(directory=REP_MIGRATIONS) flask_migrate.migrate()
def nmap(): with app.app_context(): info = Monitor.query.all() if info is None: exit(1) ip = '' for item in info: ip = ip + item.ipaddr + ' ' nmap = nmap3.NmapHostDiscovery() results = nmap.nmap_no_portscan(ip) db.session.execute(Monitor.__table__.update(), [{'isok': '0'}]) db.session.commit() if results is None: exit(1) for i in range(0, len(results['hosts'])): ip = results['hosts'][i]['addr'] status = 1 if results['hosts'][i]['state'] == 'up' else '0' mon = Monitor.query.filter_by(ipaddr=ip).first() if mon: mon.update_time = getCurrentDate() mon.isok = status db.session.add(mon) db.session.execute(MonLog.__table__.insert(), [{ 'mon_id': mon.id, 'update_time': getCurrentDate() }]) db.session.commit()
def CreationDB(): """ Création de la DB """ with app.app_context(): if "mysql" in app.config["SQLALCHEMY_DATABASE_URI"]: # Création d'une base MySQL app.logger.info( "Creation de la base de donnees MySQL si besoin...") import sqlalchemy temp = app.config["SQLALCHEMY_DATABASE_URI"].split("/") url = temp[0] + "//" + temp[2] nom_db = temp[3].split("?")[0] engine = sqlalchemy.create_engine(url) engine.execute("CREATE DATABASE IF NOT EXISTS %s;" % nom_db) engine.execute("USE %s;" % nom_db) engine.dispose() app.logger.info("Creation des tables des donnees...") db.create_all() app.logger.info("Creation ok.") if os.path.isdir(REP_MIGRATIONS): app.logger.info("Suppression du repertoire migrations...") shutil.rmtree(REP_MIGRATIONS) app.logger.info("Initialisation de la migration de sqlalchemy...") flask_migrate.init(directory=REP_MIGRATIONS) app.logger.info("Initialisation ok.") # Mémorisation du numéro de version dans la DB m = Parametre(nom="version", parametre=app.config["VERSION_APPLICATION"]) db.session.add(m) db.session.commit()
def sync_delete(app, datas): with app.app_context(): for data in datas: cur_goods = Goods.query.filter_by(goods_id=data.goods_id).first() if cur_goods is not None: db.session.delete(cur_goods) db.session.commit()
def test_compare_borrower_bad(self, mock_register_adapter): with app.app_context() as ac: ac.g.trace_id = None with app.test_request_context(): mock_register_adapter.return_value = ["Alice", "Bob"] self.assertRaises(BorrowerNamesDifferException, compare_borrower_names, PAYLOAD)
def all_tasks(): from application import app with app.app_context(): task_obj_list = TasksModel.query.filter_by(is_deleted=False, status=True).all() ret = dict() for task_obj in task_obj_list: _task_dict = { "year": task_obj.year, "month": task_obj.month, "day": task_obj.day, "week": task_obj.week, "day_of_week": task_obj.day_of_week, "hour": task_obj.hour, "minute": task_obj.minute, "second": task_obj.second, } task_dict = {"trigger": task_obj.task_type} for k, v in _task_dict.items(): if v is not None: task_dict[k] = v ret[task_obj.task_no] = task_dict return ret
def test_delete(self): response = self.client.post('admin') with app.app_context(): product = db.session.execute( 'SELECT * FROM products WHERE id=2').fetchone() assert product is None
def get_book(self, db, book_id): with app.app_context(): book = db.session.query(Book).filter(Book.id == book_id).first() if book == None: return Response("", status=404) return jsonify(book.serialize)
def test_create(self): assert self.client.get('/admin').status_code == 200 self.client.post('/admin', data={'title': 'created', 'body': ''}) with app.app_context(): count = db.session.execute( 'SELECT COUNT(id) FROM products').fetchone()[0] assert count == 1
def test_create_deed_html(self, mock_format): deed = DeedModelMock mock_format.return_value = 'a house' with app.app_context() as ac: ac.g.trace_id = None with app.test_request_context(): self.assertTrue('Digital Mortgage Deed' in create_deed_html(deed.deed)) self.assertTrue('e-MD12344' in create_deed_html(deed.deed))
def get_video(self, db, video_id): with app.app_context(): video = db.session.query(Video).filter( Video.id == video_id).first() if video == None: return Response("", status=404) return jsonify(video.serialize)
def test_auth_sms_deed_not_found(self, mock_get_deed): with app.app_context() as ac: ac.g.trace_id = None with app.test_request_context(): mock_get_deed.return_value = None with self.assertRaises(NotFound): auth_sms("11", "11", "11")
def test_calls_decorated_function(self): with app.app_context(): @as_feature_collection def stub_function(): return 'STUB_STRING' result = stub_function() self.assertEqual('STUB_STRING', result)
def test_borrowers_present_bad(self, mock_register_adapter): with app.app_context() as ac: ac.g.trace_id = None with app.test_request_context(): mock_register_adapter.return_value = [ "Jake Bullet", "Jill Beatrix Bullet", "Another Name" ] self.assertRaises(BorrowerNamesMissingException, all_borrower_names_present, PAYLOAD)
def drop_table(cls): if ORM == 'peewee': cls.model.drop_table(True) elif ORM == 'sql-alchemy': with app.app_context(): db.session.remove() db.drop_all() elif ORM == 'mongo_engine': cls.model.drop_collection()
def setUp(self): app.config.from_object('config.TestingConfig') self.client = app.test_client() db.init_app(app) with app.app_context(): db.create_all() user_datastore.create_user(email='test', password=encrypt_password('test')) db.session.commit()
def test_auth_sms_no_esec_id(self, mock_get_deed, mock_get_borrower, mock_convert_json, mock_borrower_pos, mock_akuma): mock_get_borrower.return_value = BorrowerModelMock with app.app_context() as ac: ac.g.trace_id = None with app.test_request_context(): mock_get_deed.return_value = DeedModelMock() with self.assertRaises(InternalServerError): auth_sms("11", "11", "11")
def client(): app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database_test.db' app.config['TESTING'] = True with app.test_client() as client: with app.app_context(): init_db() yield client
def test_create_deed_html_with_date_of_mortgage_offer(self, mock_format): deed = MortgageDocMockWithDateOfMortgageOffer mock_format.return_value = 'a house' with app.app_context() as ac: ac.g.trace_id = None with app.test_request_context(): self.assertTrue('Digital Mortgage Deed' in create_deed_html(deed.deed)) self.assertTrue('e-MD1291A' in create_deed_html(deed.deed)) self.assertTrue('Date of Mortgage Offer' in create_deed_html(deed.deed)) self.assertTrue('a date string' in create_deed_html(deed.deed))
def reset(app): with app.app_context(): db.drop_all() db.create_all() test_product = Product(name="Snake Oil", price=9.99, stock=3) db.session.add(test_product) test_product2 = Product(name="Trump Steaks", price=999.99, stock=10) db.session.add(test_product2) db.session.commit()
def test_auth_sms_akuma_result_z(self, mock_get_deed, mock_akuma): with app.app_context() as ac: ac.g.trace_id = None with app.test_request_context(): mock_get_deed.return_value = DeedModelMock() mock_akuma.return_value = { "result": "Z", "id": "2b9115b2-d956-11e5-942f-08002719cd16" } result = auth_sms("11", "11", "11") self.assertEqual(result, 'Failed to sign Mortgage document')
def get_recommendations(self, app): with app.app_context(): books = Book.query.all() videos = Video.query.all() blogs = Blog.query.all() dict = { "book": [book.serialize for book in books], "video": [video.serialize for video in videos], "blog": [blog.serialize for blog in blogs] } return jsonify(dict)
def test_update(self): assert self.client.get('/admin').status_code == 200 self.client.post('/admin', data={ 'productPrice': 'updated', 'body': '' }) with app.app_context(): up = db.session.execute( 'SELECT * FROM products WHERE id=1').fetchone() assert up['productPrice'] == 10.0
def add_entry_task(title, text): """ Definicao da task para salvar um novo post :param title: titulo do post :param text: conteudo do post :return: None """ with app.app_context(): logger.info('Processing add_entry_task....') entry = Entry(title, text) db.session.add(entry) db.session.commit() logger.info('Finished.')
def CreationDB(): """ Création de la DB """ with app.app_context(): app.logger.info("Creation de la base de donnees...") db.create_all() app.logger.info("Creation ok.") app.logger.info("Initialisation de la migration de sqlalchemy...") flask_migrate.init() app.logger.info("Initialisation ok.") # Mémorisation du numéro de version dans la DB m = Parametre(nom="version", parametre=app.config["VERSION_APPLICATION"]) db.session.add(m) db.session.commit()
def send_email(app, to, subject, body): with app.app_context(): sg = sendgrid.SendGridClient("SG.pRFA8c9bRXXXXXXXXXXXXXXXXXXXXXXXXX") message = sendgrid.Mail() message.add_to(to) message.set_subject(subject) message.set_html(body) message.set_from('Template No-Reply <*****@*****.**>') try: status, msg = sg.send(message) print("Status: " + str(status) + " Message: " + str(msg)) if status == 200: return True except Exception, ex: print("------------ ERROR SENDING EMAIL ------------" + str(ex.message))
def test_create_user(self): with app.app_context(): user = User.create(email='*****@*****.**', password='******', auth_type='simple') assert user facebook_user = User.create(email='*****@*****.**', auth_type='facebook', auth_id='12345', auth_token='token') assert facebook_user instagram_user = User(email='*****@*****.**', auth_type='instagram', auth_id='123456', auth_token='token1') instagram_user.save()
def UpgradeDB(): """ Mise à jour de la DB """ with app.app_context(): app.logger.info("Migration de la base de donnees...") try : flask_migrate.migrate() except Exception, err : if "Path doesn't exist" in str(err) : app.logger.info("Repertoire Migrations manquant -> Initialisation de flask_migrate maintenant...") flask_migrate.init() flask_migrate.migrate() app.logger.info("Migration ok.") app.logger.info("Upgrade de la base de donnees...") flask_migrate.upgrade() app.logger.info("Upgrade ok.")
def send_email(player_name, title, body_text, cc=None): player_full_name, email_address = get_player_email(player_name) if cc: cc = get_players_email(cc) if email_address is None: return False with app.app_context(): mailer = Mail(app) message = Message(title, recipients=[(player_full_name, email_address)]) message.body = body_text if cc: message.cc = cc message.reply_to = cc[0] mailer.send(message) return True
def create_data(): with app.app_context(): from application import db import models db.create_all()
def create_table(cls): if ORM == 'peewee': cls.model.create_table(True) elif ORM == 'sql-alchemy': with app.app_context(): db.create_all()
def setUpClass(cls): app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://{user}:{password}@{host}/{database}'.format(**config) app.app_context().push() db.init_app(app) cls.app = app.test_client()
def test_get_user(self): with app.app_context(): user = User.get(email='*****@*****.**') assert user assert not User.get(email='*****@*****.**')
def init_db(): with app.app_context(): db = get_db() with app.open_resource('databases/schema.sql', mode='r') as f: db.cursor().executescript(f.read()) db.commit()
def test_get_document(self): with app.app_context(): with app.test_request_context(): resp = get_document() self.assertEqual(str(resp.mimetype), "application/pdf")
# Setup Admin ================================================================ init_admin() # Bootstrap ================================================================== def create_test_models(): user_datastore.create_user(email='test', password=encrypt_password('test')) user_datastore.create_user(email='test2', password=encrypt_password('test2')) stuff = SomeStuff(data1=2, data2='toto', user_id=1) db.session.add(stuff) stuff = SomeStuff(data1=5, data2='titi', user_id=1) db.session.add(stuff) db.session.commit() @app.before_first_request def bootstrap_app(): if not app.config['TESTING']: if db.session.query(User).count() == 0: create_test_models() # Start server =============================================================== if __name__ == '__main__': db.init_app(app) with app.app_context(): db.create_all() app.run()
def test_protectedstuff(self): with app.app_context(): instance = SomeStuff(data1=1337, data2='Test') db.session.add(instance) db.session.commit() self.assertTrue(hasattr(instance, 'id'))
def test_content_type(self): with app.app_context(): response = self.get_response() self.assertEqual(response.headers['Content-Type'], 'application/json')
# -*- coding: utf-8 -*- from application import app if __name__ == '__main__': with app.app_context(): from tasks import celery celery.worker_main(argv=[''])
def send_async_email_helper(msg): with app.app_context(): mail.send(msg)
# -*- coding: utf-8 -*-
def tearDown(self): with app.app_context(): db.session.remove() db.drop_all()
def test_error_handlers(self): with app.app_context(): self.assertTrue(400 in app.error_handler_spec[None]) self.assertTrue(401 in app.error_handler_spec[None]) self.assertTrue(404 in app.error_handler_spec[None]) self.assertTrue(500 in app.error_handler_spec[None])