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")
