def main(): db.drop_all() db.create_all() if len(sys.argv) > 1 and sys.argv[1] == 'd': # Entering some sample data b = Board('Random', 'b', True) b_thread1 = Thread(b, 'A Subject') b_thread1_post1 = Post(b_thread1, 'Person 1', 'First post content', None, '*****@*****.**', datetime.datetime.now()) b_thread1_post2 = Post(b_thread1, 'Person 2', 'Second post content', None, '*****@*****.**', datetime.datetime.now()) b_thread1_post3 = Post(b_thread1, 'Person 3', 'Third post content', None, '*****@*****.**', datetime.datetime.now()) # The UndefinedVariable comments tell PyDev to suppress errors that it # wrongly generates for the add and commit methods. db.session.add(b) #@UndefinedVariable db.session.add(b_thread1) #@UndefinedVariable db.session.add(b_thread1_post1) #@UndefinedVariable db.session.add(b_thread1_post2) #@UndefinedVariable db.session.add(b_thread1_post3) #@UndefinedVariable db.session.commit() #@UndefinedVariable print('The database has been set up.')
def createdb(): """ Create Database (with initial user) """ import models db.create_all() add_user(u'admin', email=get_emailaddress())
def add_posts_to_db(): db.drop_all() db.create_all() for post in posts: db.session.add(Post(post["name"], post["max_votes"], post["applied_hostel"], post["help_text"])) db.session.commit()
def createDB(): "create a database" db.create_all() if not os.path.exists(SQLALCHEMY_MIGRATE_REPO): api.create(SQLALCHEMY_MIGRATE_REPO, 'database repository') api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) else: api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, api.version(SQLALCHEMY_MIGRATE_REPO))
def setUp(self): db.create_all() with self.app.test_request_context(): u = models.User(username=self.username, email=u'') u.set_password(self.password) db.session.add(u) db.session.commit()
def init_db(): # import all modules here that might define models so that # they will be registered properly on the metadata. Otherwise # you will have to import them first before calling init_db() print "Importing models" print "Creating all tables" db.create_all()
def setUp(self): db.create_all() member = Members(first_name="Bjarne", last_name="Betjent", position="member", phone="666", mail="*****@*****.**") db.session.add(member) db.session.commit()
def populate_all(): db.drop_all() db.create_all() create_roles() create_user() create_books() db.session.commit()
def init_db(used_app): with used_app.app_context(): db.create_all() admin_init() group_init() user_group_init() permission_init() group_permission_init()
def syncdb(): """Create the database tables (if they don't exist)""" from bundles.users.models import create_admin print 'Founded this tables:' print ' '.join(db.Model.metadata.tables.keys()) print 'Creating tables if needed...' db.create_all() print 'Done.' create_admin()
def setUp(self): """ create test database connection """ import os try: os.remove('test.db') except OSError: pass app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db' db.create_all()
def setUp(cls): if not cls.setup: os.environ["FLASK_ENV"] = "testing" cls.app = create_app() cls.app_context = cls.app.app_context() cls.app_context.push() db.drop_all() db.create_all() cls.client = cls.app.test_client() cls.setup = True return cls
def init_db(): db.drop_all() db.create_all() with open("test3.json") as test_json: test_data = json.load(test_json) for item in test_data['items']: book = Book(item["volumeInfo"]['title'], item["volumeInfo"]['categories'][0], item["volumeInfo"]['publishedDate'], 420, item["volumeInfo"]['industryIdentifiers'][1]["identifier"], item["saleInfo"]['retailPrice']['amount'])
def seed(): """Add seed data to the database.""" db.create_all() john = User(username='******') post = Post() post.title = "Story time at Libray" post.body = "This is the first post" post.author = john db.session.add(post) db.session.add(john) db.session.commit() print(User.query.all()) print(Post.query.all())
def test_create_meals(self): # test data is loaded successfully db.drop_all() db.create_all() mealId1 = self.json_file["meals"][0]["idMeal"] # expect index out of bounds exception with self.assertRaises(IndexError): response = self.app.get("/meals/" + str(mealId1)) create_meals() all_meals = db.session.query(Meal_Name).all() self.assertEqual(len(all_meals), len(self.json_file["meals"])) response = self.app.get("/meals/" + str(mealId1)) self.assertEqual(response.status, "200 OK")
def db_start(): create_engine('sqlite:///tmp/test.db', convert_unicode=True) db.create_all() db.session.commit() user = models.User() user.username = "******" user.password = bcrypt.generate_password_hash('pppp1234') user.email = '*****@*****.**' user.admin = True user.poweruser = True db.session.add(user) db.session.commit()
def get_app(): app = create_app() root = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..') try: os.remove(os.path.join(root, 'var', 'test.db')) except OSError: pass os.environ['SETTINGS_FILE'] = os.path.join(root, 'config', 'test.cfg') with app.app_context(): db.create_all() CreateBankAccounts().run() CreateTickets().run() return app.test_client(), app, db
def setUp(cls): cls.app = create_app() # creates an app cls.app.config.from_object( 'default_settings.Testing') # forces testing configuration cls.app_context = cls.app.app_context() # app_context is retrieved cls.app_context.push() # binds app context to the current context cls.client = cls.app.test_client( ) # test client is made using the app context db.drop_all() db.create_all() # invokes 'flask db_cli seed' in console runner = cls.app.test_cli_runner() runner.invoke(args=["db_cli", "seed"])
def app_factory(cache): if "SETTINGS_FILE" not in os.environ: root = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") os.environ["SETTINGS_FILE"] = os.path.join(root, "config", "test.cfg") tmpdir = os.environ.get("TMPDIR", "/tmp") prometheus_dir = os.path.join(tmpdir, "emf_test_prometheus") os.environ["prometheus_multiproc_dir"] = prometheus_dir if os.path.exists(prometheus_dir): shutil.rmtree(prometheus_dir) if not os.path.exists(prometheus_dir): os.mkdir(prometheus_dir) # For test purposes we're perpetually 2 weeks into ticket sales and 10 weeks before the event. fake_event_start = datetime.datetime.now() + datetime.timedelta(weeks=10) config_override = { "SALES_START": (datetime.datetime.now() - datetime.timedelta(weeks=2)).isoformat(), "EVENT_START": fake_event_start.isoformat(), "EVENT_END": (fake_event_start + datetime.timedelta(days=4)).isoformat(), } if cache: config_override["CACHE_TYPE"] = "simple" app = create_app(dev_server=True, config_override=config_override) with app.app_context(): try: db_obj.session.close() except: pass db_obj.drop_all() # We're not using migrations here so we have to create the extension manually db_obj.session.execute(text("CREATE EXTENSION IF NOT EXISTS postgis")) db_obj.session.commit() db_obj.session.close() db_obj.create_all() create_bank_accounts() create_product_groups() yield app db_obj.session.close() db_obj.drop_all()
def init_reporting(): # http://docs.sqlalchemy.org/en/rel_0_9/dialects/mysql.html#module-sqlalchemy.dialects.mysql.mysqlconnector user = get_param(Constant.DB_REPORTING_USER) passwd = get_param(Constant.DB_REPORTING_PASS) uri = str(get_param(Constant.DB_REPORTING_LOCATION)) uri_final = uri.replace('<user>', user).replace('<passwd>', passwd) SQLALCHEMY_BINDS = { Constant.DB_REPORTING_ID: uri_final # , 'appmeta': 'sqlite:////path/to/appmeta.db' } app.config['SQLALCHEMY_BINDS'] = SQLALCHEMY_BINDS db.create_all(bind=Constant.DB_REPORTING_ID) Constant.HAS_LOCAL_DB_REPORTING_CAPABILITY = True check_history_tables()
def _set_up_client(request): app_context = app.app_context() app_context.push() def tear_down_client(): db.drop_all() db.session.commit() app_context.pop() request.addfinalizer(tear_down_client) db.configure_mappers() db.create_all() db.session.commit()
def main(): with app.app_context(): if os.getenv('FLASK_ENV') not in ['testing']: raise Exception('TESTS IS ALLOWED TO RUN ONLY END TESTING MODE') try: os.remove('src/test_data/test.db') except IOError: print('Not found test db') db.create_all() suite = TestLoader().discover( 'tests', pattern='test_*.py', top_level_dir=os.environ['PYTHONPATH'].split(os.pathsep)[0] ) return TextTestRunner(verbosity=1).run(suite)
def init_db(): """删除数据库中所有数据并初始化""" db.drop_all() db.create_all() admins = Role(id=1, name='管理员') admins.save() admins.set_permission('user') admins.set_permission('users') users = Role(id=2, name='普通用户') users.save() print("The database has been created.")
def client(): test_client = app.test_client() db.drop_all() db.create_all() user = User(username='******') user.set_password_hash('123456') db.session.add(user) db.session.commit() yield test_client """ tearDown code """ db.session.remove() db.drop_all()
def setUp(self): """create temporary database to testing the application""" self.db_fd, app.config['DATABASE'] = tempfile.mkstemp() app.testing = True self.app = app.test_client() with app.app_context(): db.create_all() self.comment_data = { 'name': 'admin', 'email': '*****@*****.**', 'url': 'http://localhost', 'ip_address': '127.0.0.1', 'body': 'Test comment', 'entry_id': 1 }
def initialize(): db.create_all() # user_type type_admin = UserType() type_admin.type = 1 type_admin.name = 'ADMIN' type_normal = UserType() type_normal.type = 2 type_normal.name = 'USER' type_superadmin = UserType() type_superadmin.type = 3 type_superadmin.name = 'SUPERADMIN' cl.add_params('user_type-1', type_admin, type_normal) cl.add_params('user_type-2', type_superadmin) """
def country(): wb = xlrd.open_workbook("/Users/liyin/Downloads/1.xlsx") wb.sheet_names() sh = wb.sheet_by_name(u'Sheet1') count = 0 for rownum in range(sh.nrows): country = Country( sh.row_values(rownum)[0], sh.row_values(rownum)[1], sh.row_values(rownum)[2]) db.session.add(country) db.session.commit() db.create_all() count += 1 print count
def importCountry(): if request.method == "POST": basedir = os.path.abspath(os.path.dirname(__file__)) file_dir = os.path.join(basedir, 'upload') if not os.path.exists(file_dir): os.makedirs(file_dir) unix_time = int(time.time()) f = request.files['file'] new_filename = str(unix_time) + '.xlsx' # 修改了上传的文件名 f.save(os.path.join(file_dir, new_filename)) # 保存文件到upload目录 try: data = xlrd.open_workbook(file_dir + "/" + new_filename) except Exception, e: print e table = data.sheets()[0] nrows = table.nrows ncols = table.ncols data = [] for rownum in range(1, nrows): date = [] timea = [] for col in range(1, ncols): timea.append( xlrd.xldate.xldate_as_datetime( table.row_values(0)[col], 1).strftime("%Y-%m-%d")) date.append(table.row_values(rownum)[col]) result = { "country": table.row_values(rownum)[0], "date": date, "time": timea } data += [result] for i in data: for j in range(len(i["time"])): time_coun = i["time"][j] price = '%0.2f' % (i["date"][j]) country = i['country'] coun = Country.query.filter_by(shorthand=country).first() timePrice = TimePrice(coun.id, time_coun, price) db.session.add(timePrice) db.session.commit() db.create_all() response = {"code": 200, "data": data, "message": "success"}
def db_start(): create_engine('sqlite:///tmp/test.db', convert_unicode=True) db.create_all() db.session.commit() user_1 = models.User() user_1.username = "******" user_1.password = bcrypt.generate_password_hash('pppp1234') user_1.email = '*****@*****.**' user_1.admin = True user_1.poweruser = True db.session.add(user_1) db.session.commit() user_2 = models.User() user_2.username = "******" user_2.password = bcrypt.generate_password_hash('ewelina1') user_2.email = '*****@*****.**' user_2.admin = False user_2.poweruser = False db.session.add(user_2) db.session.commit() user_3 = models.User() user_3.username = "******" user_3.password = bcrypt.generate_password_hash('qwertyuiop') user_3.email = '*****@*****.**' user_3.admin = True user_3.poweruser = True db.session.add(user_3) db.session.commit() user_4 = models.User() user_4.username = "******" user_4.password = bcrypt.generate_password_hash('admin') user_4.email = '*****@*****.**' user_4.admin = True user_4.poweruser = True db.session.add(user_4) db.session.commit() '''
def db_start(): create_engine('sqlite:///tmp/testapi.db', convert_unicode=True) db.create_all() db.session.commit() product_1 = models.Product() product_1.name = 'Computer' product_1.description = 'Very big comupter' product_1.category = 'Personal computer' db.session.add(product_1) db.session.commit() review_1 = models.Review() review_1.author = 'Johny' review_1.text = 'Very nice computer' review_1.rating = 5 review_1.product_id = 1 db.session.add(review_1) db.session.commit()
def first(): db.create_all() form = RegistrationForm() if form.validate_on_submit(): print('true') pett = Pet(kind=form.kind.data, nickname=form.nickname.data, age=form.age.data) db.session.add(pett) db.session.commit() # print(form.kind.data) # print(form.nickname.data) # print(form.age.data) print(db.session.query(Pet).count()) flash(u'Питомец {} записан!'.format(form.nickname.data)) return redirect(url_for('second')) print(db.session.query(Pet).count()) return render_template('first.html', form=form)
def setUp(cls) -> None: os.environ["FLASK_ENV"] = "testing" cls.app = create_app() cls.app_context = cls.app.app_context() cls.app_context.push() db.create_all() cls.client = cls.app.test_client() cls.create_user("user5", "*****@*****.**") cls.create_user("user6", "*****@*****.**") cls.create_user("user7", "*****@*****.**") cls.create_user("user8", "*****@*****.**") cls.user5_auth_header = cls.auth_user("user5")[1] cls.user6_auth_header = cls.auth_user("user6")[1] cls.user7_auth_header = cls.auth_user("user7")[1] cls.user8_auth_header = cls.auth_user("user8")[1]
def setUp(cls) -> None: os.environ["FLASK_ENV"] = "testing" cls.app = create_app() cls.app_context = cls.app.app_context() cls.app_context.push() db.create_all() cls.client = cls.app.test_client() cls.create_user("user1", "*****@*****.**") cls.create_user("user2", "*****@*****.**") cls.create_user("user3", "*****@*****.**") cls.create_user("user4", "*****@*****.**") cls.user1_auth_header = cls.auth_user("user1")[1] cls.user2_auth_header = cls.auth_user("user2")[1] cls.user3_auth_header = cls.auth_user("user3")[1] cls.user4_auth_header = cls.auth_user("user4")[1]
def setUp(self): class TestConfig(object): SQLALCHEMY_DATABASE_URI = 'sqlite://' DEBUG = True TESTING = True app.config.from_object(TestConfig()) self.app = app with self.app.test_request_context(): db.create_all() raw_users = [ { 'username': '******', 'email': '*****@*****.**', 'password': '******' }, { 'username': '******', 'email': '*****@*****.**', 'password': '******' }, { 'username': '******', 'email': '*****@*****.**', 'password': '******' } ] raw_groups = [ { 'name': 'group1' }, { 'name': 'group2' }, { 'name': 'group3' } ] for user in raw_users: password = user.pop('password') user = User(**user) user.set_password(password) user.save() for group in raw_groups: Group(**group).save()
def app(): """ Fixture to provide an instance of the app. This will also create a Flask app_context and tear it down. This fixture is scoped to the module level to avoid too much Postgres teardown/creation activity which is slow. """ if 'SETTINGS_FILE' not in os.environ: root = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..') os.environ['SETTINGS_FILE'] = os.path.join(root, 'config', 'test.cfg') tmpdir = os.environ.get('TMPDIR', '/tmp') prometheus_dir = os.path.join(tmpdir, 'emf_test_prometheus') os.environ['prometheus_multiproc_dir'] = prometheus_dir if os.path.exists(prometheus_dir): shutil.rmtree(prometheus_dir) if not os.path.exists(prometheus_dir): os.mkdir(prometheus_dir) app = create_app() with app.app_context(): try: db_obj.session.close() except: pass db_obj.drop_all() # We're not using migrations here so we have to create the extension manually db_obj.session.execute(text("CREATE EXTENSION IF NOT EXISTS postgis")) db_obj.session.commit() db_obj.session.close() db_obj.create_all() CreateBankAccounts().run() CreateTickets().run() yield app db_obj.session.close() db_obj.drop_all()
def app(): """ Fixture to provide an instance of the app. This will also create a Flask app_context and tear it down. This fixture is scoped to the module level to avoid too much Postgres teardown/creation activity which is slow. """ if "SETTINGS_FILE" not in os.environ: root = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") os.environ["SETTINGS_FILE"] = os.path.join(root, "config", "test.cfg") tmpdir = os.environ.get("TMPDIR", "/tmp") prometheus_dir = os.path.join(tmpdir, "emf_test_prometheus") os.environ["prometheus_multiproc_dir"] = prometheus_dir if os.path.exists(prometheus_dir): shutil.rmtree(prometheus_dir) if not os.path.exists(prometheus_dir): os.mkdir(prometheus_dir) app = create_app() with app.app_context(): try: db_obj.session.close() except: pass db_obj.drop_all() # We're not using migrations here so we have to create the extension manually db_obj.session.execute(text("CREATE EXTENSION IF NOT EXISTS postgis")) db_obj.session.commit() db_obj.session.close() db_obj.create_all() create_bank_accounts() create_product_groups() yield app db_obj.session.close() db_obj.drop_all()
def test_role(test_client): db.create_all() # User roles = Role.insert_roles() assert Role.query.all()[0].name == 'USER' assert Role.query.all()[0].default == True assert Role.query.all()[0].permissions == 3 perm = Role.query.all()[0].has_permission(3) assert Role.query.all()[0].permissions & perm == perm Role.query.all()[0].add_permission(4) assert Role.query.all()[0].permissions == 7 Role.query.all()[0].remove_permission(3) assert Role.query.all()[0].permissions == 4 Role.query.all()[0].reset_permission() assert Role.query.all()[0].permissions == 0
def setUp(cls) -> None: os.environ["FLASK_ENV"] = "testing" cls.app = create_app() cls.app_context = cls.app.app_context() cls.app_context.push() db.create_all() cls.client = cls.app.test_client() cls.reg_response = cls.client.post("/user/", json={ "city": "melbounre", "country": "Australia", "created_at": "2020-12-26 20:45:09", "dob": "1995-08-06 00:00:00", "email": "*****@*****.**", "first_name": "Michael", "last_name": "Rixon", "mobile": "001-380-382-7166x368", "username": "******", "password": "******" }) print("initialise users") print(cls.reg_response.status_code) print(cls.reg_response.get_json()) cls.client.post("/user/", json={ "city": "melbourne", "country": "Australia", "created_at": "2020-12-26 20:45:09", "dob": "1995-08-06 00:00:00", "email": "*****@*****.**", "first_name": "Michael", "last_name": "Rixon", "mobile": "001-380-382-7166x368", "username": "******", "password": "******" })
def test_new_user(test_client): db.create_all() user = User(first_name='Paul', last_name='Asalu', email='*****@*****.**', tel='09045444444', country='Nigeria', state='Lagos', address='66 Baruwa Street, Agboju', age=22, user_id='1234', sign_up_date=d.datetime.utcnow(), sign_up_method='Firebase', days_left=1) Role.insert_roles() role = Role.query.filter_by(id=1).first() user.role = role Guides.insert_guides() guide = Guides.query.filter_by(id=1).first() user.guides.append(guide) db.session.add(user) db.session.commit() assert user.first_name == 'Paul' assert user.last_name == 'Asalu' assert user.email == '*****@*****.**' assert user.tel == '09045444444' assert user.country == 'Nigeria' assert user.state == 'Lagos' assert user.address == '66 Baruwa Street, Agboju' assert user.travel_history == 0 assert user.age == 22 assert user.user_id == '1234' assert user.sign_up_date == user.sign_up_date assert user.sign_up_method == 'Firebase' assert user.med_state == 'Mild' assert user.days_left == 1 assert user.role.name == 'USER' db.drop_all()
def setUp(self): class TestConfig(object): SQLALCHEMY_DATABASE_URI = 'sqlite://' DEBUG = True TESTING = True app.config.from_object(TestConfig()) self.app = app with self.app.test_request_context(): db.create_all() raw_users = [{ 'username': '******', 'email': '*****@*****.**', 'password': '******' }, { 'username': '******', 'email': '*****@*****.**', 'password': '******' }, { 'username': '******', 'email': '*****@*****.**', 'password': '******' }] raw_groups = [{ 'name': 'group1' }, { 'name': 'group2' }, { 'name': 'group3' }] for user in raw_users: password = user.pop('password') user = User(**user) user.set_password(password) user.save() for group in raw_groups: Group(**group).save()
def initdb(drop): if drop: click.confirm('你想删除全部数据吗?', abort=True) db.drop_all() click.echo('已删除') db.create_all() admin = User.query.filter_by(is_admin=True).first() if admin: password = os.getenv("ADMIN_PASSWORD") username = os.getenv("ADMIN_USERNAME") admin.username = username admin.set_password(password) else: password = os.getenv("ADMIN_PASSWORD") username = os.getenv("ADMIN_USERNAME") name = os.getenv("ADMIN_NAME") email = os.getenv("ADMIN_EMAIL") admin = User(username=username,name=name,email=email,Intellectual_disability=0,is_admin=True) admin.set_password(password) db.session.add(admin) db.session.commit() click.echo('已完成')
def app(): """ Fixture to provide an instance of the app. This will also create a Flask app_context and tear it down. This fixture is scoped to the module level to avoid too much Postgres teardown/creation activity which is slow. """ if 'SETTINGS_FILE' not in os.environ: root = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..') os.environ['SETTINGS_FILE'] = os.path.join(root, 'config', 'test.cfg') tmpdir = os.environ.get('TMPDIR', '/tmp') prometheus_dir = os.path.join(tmpdir, 'emf_test_prometheus') os.environ['prometheus_multiproc_dir'] = prometheus_dir if os.path.exists(prometheus_dir): shutil.rmtree(prometheus_dir) if not os.path.exists(prometheus_dir): os.mkdir(prometheus_dir) app = create_app() with app.app_context(): try: db_obj.session.close() except: pass db_obj.drop_all() db_obj.create_all() CreateBankAccounts().run() CreateTickets().run() yield app db_obj.session.close() db_obj.drop_all()
def setUp(cls): cls.app = create_app() cls.app_context = cls.app.app_context() cls.app_context.push() cls.client = cls.app.test_client() db.create_all() runner = cls.app.test_cli_runner() result_seed = runner.invoke(args=["db-custom", "seed"]) if result_seed.exit_code != 0: raise ValueError(result_seed.stdout) cls.headers = {} for i in range(1, 6): cls.login = cls.client.post("users/login", json={ "email": f"test{i}@test.com", "password": "******" }) cls.token = cls.login.get_json()["token"] cls.header = {"Authorization": f"Bearer {cls.token}"} cls.headers[f"test{i}"] = cls.header cls.headers["fakeuser"] = {"Authorization": "Bearer invalid_token"}
def setUp(self): app.config['TESTING'] = True app.config['CSRF_ENABLED'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root@localhost/flask2' self.app = app.test_client() db.create_all()
def setUp(self): db.create_all() server = Servers(uid=8, server_name="creeper", ip_address="129.242.219.41") db.session.add(server) db.session.commit()
def reset(): db.drop_all() db.create_all() return 'Success: reset'
def setUp(self): db.create_all() add_some_data(username=self.username)
def setUp(self): db.create_all()
def resetTables(): db.drop_all() db.create_all()
def init_db(): from main import db db.create_all()
def setUp(self): """尝试创建一个测试环境""" self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() db.create_all()
def create_db(): db.create_all() return 'Success!'
def setUp(self): app.config['TESTING'] = True app.config['WTF_CSRF_ENABLED'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db') self.app = app.test_client() db.create_all()
def run(self): from main import db db.create_all()
from main import initalize_app, db db.create_all(app=initalize_app())
def setUp(self): db.drop_all() db.create_all()
def run(self): db.create_all()
import os, sys sys.path.append(os.getcwd()) from main import db if __name__=='__main__': db.create_all()
def setUp(self): self.driver = webdriver.Firefox() self.driver.implicitly_wait(10) print("before create all") db.create_all() print("after create all")