def create_db():
"""Creates the development database"""
from bespin import config, database, db_versions
from migrate.versioning.shell import main
config.set_profile('dev')
base_url = config.c.dburl
config_file = options.server.config_file
if config_file.exists():
info("Loading config: %s", config_file)
code = compile(config_file.bytes(), config_file, "exec")
exec code in {}
if config.c.dburl == base_url and path("devdata.db").exists():
raise BuildFailure("Development database already exists")
config.activate_profile()
dry("Create database tables",
database.Base.metadata.create_all,
bind=config.c.dbengine)
repository = str(path(db_versions.__file__).dirname())
dburl = config.c.dburl
result = sh("python bespin/db_versions/manage.py version", capture=True)
dry("Turn on migrate versioning", main,
["version_control", "--version",
result.rstrip(), dburl, repository])
def start_server(args=None):
if args is None:
args = sys.argv[1:]
if args:
mode = args.pop(0)
else:
mode = "dev"
print("Bespin mobwrite worker (mode=" + mode + ")")
config.set_profile(mode)
if args:
config.load_pyconfig(args.pop(0))
if mode == "dev":
config.load_pyconfig("devconfig.py")
config.activate_profile()
app = WSGIMobWrite()
app = db_middleware(app)
serve(app,
config.c.mobwrite_server_address,
config.c.mobwrite_server_port,
use_threadpool=True)
def create_db():
"""Creates the development database"""
from bespin import config, database, db_versions
from migrate.versioning.shell import main
config.set_profile('dev')
base_url = config.c.dburl
config_file = options.server.config_file
if config_file.exists():
info("Loading config: %s", config_file)
code = compile(config_file.bytes(), config_file, "exec")
exec code in {}
if config.c.dburl == base_url and path("devdata.db").exists():
raise BuildFailure("Development database already exists")
config.activate_profile()
dry("Create database tables", database.Base.metadata.create_all, bind=config.c.dbengine)
repository = str(path(db_versions.__file__).dirname())
dburl = config.c.dburl
result = sh("python bespin/db_versions/manage.py version", capture=True)
dry("Turn on migrate versioning", main, ["version_control", "--version", result.rstrip(), dburl, repository])
def editbespin(options):
"""Use Bespin to edit Bespin. This will change the given
user's file location to the directory above Bespin, allowing
you to edit Bespin (and any other projects you have
in that directory)."""
if not 'editbespin' in options or not options.editbespin.user:
raise BuildFailure("You must specify a user with -u for this task.")
user = options.editbespin.user
from bespin import config
from bespin import database, filesystem
from sqlalchemy.orm.exc import NoResultFound
config.set_profile("dev")
config.activate_profile()
session = config.c.session_factory()
try:
user = session.query(database.User).filter_by(username=user).one()
except NoResultFound:
raise BuildFailure("I couldn't find %s in the database. Sorry!" % (user))
location = path.getcwd().parent.abspath()
user.file_location = location
user.recompute_files()
session.commit()
bespinsettings_loc = location / "BespinSettings"
if not bespinsettings_loc.exists():
project = filesystem.get_project(user, user, "BespinSettings", create=True)
project.install_template('usertemplate')
info("User %s set up to access directory %s" % (user, location))
def start():
"""Starts the BespinServer on localhost port 8080 for development.
You can change the port and allow remote connections by setting
server.port or server.address on the command line.
paver server.address=your.ip.address server.port=8000 start
will allow remote connections (assuming you don't have a firewall
blocking the connection) and start the server on port 8000.
"""
# automatically install Dojo if it's not there already
if not (options.dojo.destination / "dojo").exists():
dojo()
from bespin import config, controllers
from paste.httpserver import serve
options.order('server')
config.set_profile('dev')
if options.server.try_build:
config.c.static_dir = (options.build_dir / "frontend").abspath()
if options.server.dburl:
config.c.dburl = options.server.dburl
if options.server.async:
config.c.async_jobs = True
config.c.queue_path = path.getcwd() / "queue.db"
config.activate_profile()
port = int(options.port)
serve(controllers.make_app(), options.address, port, use_threadpool=True)
def setup_module(module):
if queue_db.exists():
print "Deleting old queue DB"
queue_db.unlink()
config.set_profile("test")
config.c.async_jobs = True
config.c.queue_path = queue_db
config.activate_profile()
def try_upgrade():
"""Run SQLAlchemy-migrate test on your database."""
from bespin import config, model, db_versions
from migrate.versioning.shell import main
config.set_profile('dev')
config.activate_profile()
repository = str(path(db_versions.__file__).dirname())
dburl = config.c.dburl
dry("Test the database upgrade", main, ["test", repository, dburl])
def upgrade():
"""Upgrade your database."""
from bespin import config, model, db_versions
from migrate.versioning.shell import main
config.set_profile('dev')
config.activate_profile()
repository = str(path(db_versions.__file__).dirname())
dburl = config.c.dburl
dry("Run the database upgrade", main, ["upgrade", dburl, repository])
def try_upgrade():
"""Run SQLAlchemy-migrate test on your database."""
from bespin import config, model, db_versions
from migrate.versioning.shell import main
config.set_profile('dev')
config.activate_profile()
repository = str(path(db_versions.__file__).dirname())
dburl = config.c.dburl
dry("Test the database upgrade", main, ["test", repository, dburl])
def upgrade():
"""Upgrade your database."""
from bespin import config, model, db_versions
from migrate.versioning.shell import main
config.set_profile('dev')
config.activate_profile()
repository = str(path(db_versions.__file__).dirname())
dburl = config.c.dburl
dry("Run the database upgrade", main, ["upgrade", dburl, repository])
def setup_module():
global app, app_murdoc
config.set_profile('test')
app = controllers.make_app()
app = BespinTestApp(app)
app_murdoc = controllers.make_app()
app_murdoc = BespinTestApp(app_murdoc)
_install_test_plugin_path()
config.activate_profile()
def setup_module(module):
global app, session
config.set_profile('test')
config.activate_profile()
Base.metadata.drop_all(bind=config.c.dbengine)
Base.metadata.create_all(bind=config.c.dbengine)
session = config.c.session_factory()
User.create_user("BillBixby", "", "*****@*****.**")
app = controllers.make_app()
app = BespinTestApp(app)
app.post("/register/login/BillBixby", dict(password=""))
def setup_module(module):
global user_manager, app, session
config.set_profile('test')
config.activate_profile()
model.Base.metadata.drop_all(bind=config.c.dbengine)
model.Base.metadata.create_all(bind=config.c.dbengine)
session = config.c.sessionmaker(bind=config.c.dbengine)
user_manager = model.UserManager(session)
user_manager.create_user("BillBixby", "", "*****@*****.**")
app = controllers.make_app()
app = TestApp(app)
app.post("/register/login/BillBixby", dict(password=""))
def seeddb():
from bespin import config, filesystem
from bespin.database import User, Connection
config.set_profile("dev")
config.activate_profile()
def get_user(name):
user = User.find_user(name)
if user == None:
user = User.create_user(name, name, name + "@foo.com")
session.commit()
info("Created user called '" + name + "'")
try:
filesystem.get_project(user, user, "BespinSettings")
except:
settings = filesystem.get_project(user,
user,
"BespinSettings",
create=True)
settings.install_template('usertemplate')
info("Created BespinSettings project for '" + name + "'")
return user
# Seriously there is something wrong with my ego today ;-)
bgalbraith = get_user("bgalbraith")
kdangoor = get_user("kdangoor")
dalmaer = get_user("d")
mattb = get_user("mattb")
zuck = get_user("zuck")
tom = get_user("tom")
ev = get_user("ev")
j = get_user("j")
bgalbraith.follow(j)
kdangoor.follow(j)
dalmaer.follow(j)
mattb.follow(j)
zuck.follow(j)
tom.follow(j)
ev.follow(j)
jproject = filesystem.get_project(j, j, "SampleProject", create=True)
j.add_sharing(jproject, bgalbraith, edit=True)
j.add_sharing(jproject, kdangoor, edit=True)
j.add_sharing(jproject, dalmaer, edit=True)
j.add_sharing(jproject, mattb, edit=False)
j.add_sharing(jproject, zuck, edit=False)
j.add_sharing(jproject, tom, edit=False)
j.add_sharing(jproject, ev, edit=False)
def test_password_change_bad_code():
config.set_profile("test")
config.activate_profile()
_clear_db()
app = controllers.make_app()
app = BespinTestApp(app)
resp = app.post('/register/new/BillBixby',
dict(email="*****@*****.**", password="******"))
app.reset()
resp = app.post('/register/password/BillBixby',
dict(code="42", newPassword="******"),
status=400)
def create_db():
"""Creates the development database"""
from bespin import config, database, db_versions
from migrate.versioning.shell import main
if path("devdata.db").exists():
raise BuildFailure("Development database already exists")
config.set_profile('dev')
config.activate_profile()
dry("Create database tables", database.Base.metadata.create_all, bind=config.c.dbengine)
repository = str(path(db_versions.__file__).dirname())
dburl = config.c.dburl
dry("Turn on migrate versioning", main, ["version_control", dburl, repository])
def test_password_change_bad_code():
config.set_profile("test")
config.activate_profile()
_clear_db()
app = controllers.make_app()
app = BespinTestApp(app)
resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**",
password="******"))
app.reset()
resp = app.post('/register/password/BillBixby', dict(
code="42",
newPassword="******"),
status=400)
def seeddb():
from bespin import config, filesystem
from bespin.database import User, Connection
config.set_profile("dev")
config.activate_profile()
def get_user(name):
user = User.find_user(name)
if user == None:
user = User.create_user(name, name, name + "@foo.com")
session.commit()
info("Created user called '" + name + "'")
try:
filesystem.get_project(user, user, "BespinSettings")
except:
settings = filesystem.get_project(user, user, "BespinSettings", create=True)
settings.install_template('usertemplate')
info("Created BespinSettings project for '" + name + "'")
return user
# Seriously there is something wrong with my ego today ;-)
bgalbraith = get_user("bgalbraith")
kdangoor = get_user("kdangoor")
dalmaer = get_user("d")
mattb = get_user("mattb")
zuck = get_user("zuck")
tom = get_user("tom")
ev = get_user("ev")
j = get_user("j")
bgalbraith.follow(j)
kdangoor.follow(j)
dalmaer.follow(j)
mattb.follow(j)
zuck.follow(j)
tom.follow(j)
ev.follow(j)
jproject = filesystem.get_project(j, j, "SampleProject", create=True)
j.add_sharing(jproject, bgalbraith, edit=True)
j.add_sharing(jproject, kdangoor, edit=True)
j.add_sharing(jproject, dalmaer, edit=True)
j.add_sharing(jproject, mattb, edit=False)
j.add_sharing(jproject, zuck, edit=False)
j.add_sharing(jproject, tom, edit=False)
j.add_sharing(jproject, ev, edit=False)
def test_lost_username(send_text_email):
config.set_profile("test")
config.activate_profile()
_clear_db()
app = controllers.make_app()
app = BespinTestApp(app)
resp = app.post('/register/new/BillBixby',
dict(email="*****@*****.**", password="******"))
resp = app.post('/register/lost/', dict(email='*****@*****.**'))
assert send_text_email.called
args = send_text_email.call_args[0]
assert args[0] == '*****@*****.**'
assert args[1].startswith("Your username for ")
assert "Your username is:" in args[2]
assert "BillBixby" in args[2]
def create_db():
"""Creates the development database"""
from bespin import config, database, db_versions
from migrate.versioning.shell import main
if path("devdata.db").exists():
raise BuildFailure("Development database already exists")
config.set_profile('dev')
config.activate_profile()
dry("Create database tables",
database.Base.metadata.create_all,
bind=config.c.dbengine)
repository = str(path(db_versions.__file__).dirname())
dburl = config.c.dburl
dry("Turn on migrate versioning", main,
["version_control", dburl, repository])
def test_lost_username(send_text_email):
config.set_profile("test")
config.activate_profile()
_clear_db()
app = controllers.make_app()
app = BespinTestApp(app)
resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**",
password="******"))
resp = app.post('/register/lost/', dict(email='*****@*****.**'))
assert send_text_email.called
args = send_text_email.call_args[0]
assert args[0] == '*****@*****.**'
assert args[1].startswith("Your username for ")
assert "Your username is:" in args[2]
assert "BillBixby" in args[2]
def main():
# Start up a thread that does timeouts and cleanup
thread.start_new_thread(cleanup_thread, ())
from bespin import config, controllers
from bespin.mobwrite.mobwrite_daemon import MobwriteWorker
config.set_profile('dev')
config.activate_profile()
logging.info("Listening on port %d..." % LOCAL_PORT)
s = SocketServer.ThreadingTCPServer(("", LOCAL_PORT), AutoPersisterEchoRequestHandler)
try:
s.serve_forever()
except KeyboardInterrupt:
logging.info("Shutting down.")
logging.shutdown()
s.socket.close()
def test_password_change_with_confirmation_code():
config.set_profile("test")
config.activate_profile()
_clear_db()
app = controllers.make_app()
app = BespinTestApp(app)
resp = app.post('/register/new/BillBixby',
dict(email="*****@*****.**", password="******"))
app.reset()
user = User.find_user("BillBixby")
verify_code = controllers._get_password_verify_code(user)
resp = app.post('/register/password/BillBixby',
dict(code=verify_code, newPassword="******"))
user = User.find_user('BillBixby', 'hatetraffic')
assert user
def test_users_can_be_locked_out():
config.set_profile("test")
config.c.login_failure_tracking = "memory"
config.c.login_attempts = "1"
config.c.lockout_period = "1"
config.activate_profile()
app = controllers.make_app()
app = BespinTestApp(app)
_clear_db()
resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**",
password="******"))
resp = app.post("/register/login/BillBixby",
dict(password="******"), status=401)
# fail with good password now, because we're locked out
resp = app.post("/register/login/BillBixby",
dict(password="******"), status=401)
def test_lost_password_request(send_text_email):
config.set_profile("test")
config.activate_profile()
_clear_db()
app = controllers.make_app()
app = BespinTestApp(app)
resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**",
password="******"))
app.reset()
resp = app.post('/register/lost/', dict(username='******'))
assert send_text_email.called
args = send_text_email.call_args[0]
assert args[0] == '*****@*****.**'
assert args[1].startswith("Requested password change for ")
user = User.find_user("BillBixby")
verify_code = controllers._get_password_verify_code(user)
assert verify_code in args[2]
def test_password_change_with_confirmation_code():
config.set_profile("test")
config.activate_profile()
_clear_db()
app = controllers.make_app()
app = BespinTestApp(app)
resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**",
password="******"))
app.reset()
user = User.find_user("BillBixby")
verify_code = controllers._get_password_verify_code(user)
resp = app.post('/register/password/BillBixby', dict(
code=verify_code,
newPassword="******"))
user = User.find_user('BillBixby', 'hatetraffic')
assert user
def test_lost_password_request(send_text_email):
config.set_profile("test")
config.activate_profile()
_clear_db()
app = controllers.make_app()
app = BespinTestApp(app)
resp = app.post('/register/new/BillBixby',
dict(email="*****@*****.**", password="******"))
app.reset()
resp = app.post('/register/lost/', dict(username='******'))
assert send_text_email.called
args = send_text_email.call_args[0]
assert args[0] == '*****@*****.**'
assert args[1].startswith("Requested password change for ")
user = User.find_user("BillBixby")
verify_code = controllers._get_password_verify_code(user)
assert verify_code in args[2]
def installkey(options):
"""Install an SSH key into your Bespin keychain. This will
prompt you for your Bespin keychain password. You must
give a Bespin username with -u. You must also specify
a passwordless SSH private key file with -f."""
if not 'installkey' in options or not options.installkey.user:
raise BuildFailure("You must specify a user with -u for this task.")
if not options.installkey.file:
raise BuildFailure("You must specify a private key with with -f")
private_key = path(options.installkey.file)
public_key = private_key + ".pub"
if not private_key.exists() or not public_key.exists():
raise BuildFailure("Either your private key file or public key file does not exist")
user = options.installkey.user
import getpass
password = getpass.getpass("Enter your keychain password: "******"dev")
config.activate_profile()
session = config.c.session_factory()
try:
user = session.query(database.User).filter_by(username=user).one()
except NoResultFound:
raise BuildFailure("I couldn't find %s in the database. Sorry!" % (user))
keychain = vcs.KeyChain(user, password)
public_key = public_key.bytes()
private_key = private_key.bytes()
keychain.set_ssh_key(private_key, public_key)
def installkey(options):
"""Install an SSH key into your Bespin keychain. This will
prompt you for your Bespin keychain password. You must
give a Bespin username with -u. You must also specify
a passwordless SSH private key file with -f."""
if not 'installkey' in options or not options.installkey.user:
raise BuildFailure("You must specify a user with -u for this task.")
if not options.installkey.file:
raise BuildFailure("You must specify a private key with with -f")
private_key = path(options.installkey.file)
public_key = private_key + ".pub"
if not private_key.exists() or not public_key.exists():
raise BuildFailure(
"Either your private key file or public key file does not exist")
user = options.installkey.user
import getpass
password = getpass.getpass("Enter your keychain password: "******"dev")
config.activate_profile()
session = config.c.session_factory()
try:
user = session.query(database.User).filter_by(username=user).one()
except NoResultFound:
raise BuildFailure("I couldn't find %s in the database. Sorry!" %
(user))
keychain = vcs.KeyChain(user, password)
public_key = public_key.bytes()
private_key = private_key.bytes()
keychain.set_ssh_key(private_key, public_key)
def process_mobwrite(args=None):
if args is None:
args = sys.argv[1:]
if args:
mode = args.pop(0)
else:
mode = "dev"
print("Bespin mobwrite worker (mode=" + mode + ")")
config.set_profile(mode)
if args:
config.load_pyconfig(args.pop(0))
config.activate_profile()
mobwrite_core.logging.basicConfig()
main()
mobwrite_core.logging.shutdown()
def process_mobwrite(args=None):
if args is None:
args = sys.argv[1:]
if args:
mode = args.pop(0)
else:
mode = "dev"
print("Bespin mobwrite worker (mode=" + mode + ")")
config.set_profile(mode)
if args:
config.load_pyconfig(args.pop(0))
config.activate_profile()
mobwrite_core.logging.basicConfig()
main()
mobwrite_core.logging.shutdown()
def test_users_can_be_locked_out():
config.set_profile("test")
config.c.login_failure_tracking = "memory"
config.c.login_attempts = "1"
config.c.lockout_period = "1"
config.activate_profile()
app = controllers.make_app()
app = BespinTestApp(app)
_clear_db()
resp = app.post('/register/new/BillBixby',
dict(email="*****@*****.**", password="******"))
resp = app.post("/register/login/BillBixby",
dict(password="******"),
status=401)
# fail with good password now, because we're locked out
resp = app.post("/register/login/BillBixby",
dict(password="******"),
status=401)
def start():
"""Starts the BespinServer on localhost port 8080 for development.
You can change the port and allow remote connections by setting
server.port or server.address on the command line.
paver server.address=your.ip.address server.port=8000 start
will allow remote connections (assuming you don't have a firewall
blocking the connection) and start the server on port 8000.
"""
# automatically install Dojo if it's not there already
if not (options.dojo.destination / "dojo").exists():
dojo()
from bespin import config, controllers
from paste.httpserver import serve
options.order('server')
config.set_profile('dev')
if options.server.try_build:
config.c.static_dir = (options.build_dir / "frontend").abspath()
if options.server.dburl:
config.c.dburl = options.server.dburl
if options.server. async:
config.c.async_jobs = True
config_file = options.server.config_file
if config_file.exists():
info("Loading config: %s", config_file)
code = compile(config_file.bytes(), config_file, "exec")
exec code in {}
config.activate_profile()
port = int(options.port)
serve(controllers.make_app(), options.address, port, use_threadpool=True)
def start():
"""Starts the BespinServer on localhost port 8080 for development.
You can change the port and allow remote connections by setting
server.port or server.address on the command line.
paver server.address=your.ip.address server.port=8000 start
will allow remote connections (assuming you don't have a firewall
blocking the connection) and start the server on port 8000.
"""
from bespin import config, controllers
from paste.httpserver import serve
options.order('server')
config.set_profile('dev')
if options.staticdir:
config.c.static_dir = path(options.clientdir) / options.staticdir
if options.server.dburl:
config.c.dburl = options.server.dburl
if options.server. async:
config.c.async_jobs = True
config.c.server_base_url = options.server_base_url
config_file = options.server.config_file
if config_file.exists():
info("Loading config: %s", config_file)
code = compile(config_file.bytes(), config_file, "exec")
exec code in {}
config.activate_profile()
port = int(options.port)
serve(controllers.make_app(), options.address, port, use_threadpool=True)
def start():
"""Starts the BespinServer on localhost port 8080 for development.
You can change the port and allow remote connections by setting
server.port or server.address on the command line.
paver server.address=your.ip.address server.port=8000 start
will allow remote connections (assuming you don't have a firewall
blocking the connection) and start the server on port 8000.
"""
from bespin import config, controllers
from paste.httpserver import serve
options.order('server')
config.set_profile('dev')
if options.staticdir:
config.c.static_dir = path(options.clientdir) / options.staticdir
if options.server.dburl:
config.c.dburl = options.server.dburl
if options.server.async:
config.c.async_jobs = True
config.c.server_base_url = options.server_base_url
config_file = options.server.config_file
if config_file.exists():
info("Loading config: %s", config_file)
code = compile(config_file.bytes(), config_file, "exec")
exec code in {}
config.activate_profile()
port = int(options.port)
serve(controllers.make_app(), options.address, port, use_threadpool=True)
def process_queue(args=None):
log.info("Bespin queue worker")
if args is None:
args = sys.argv[1:]
if args:
config.set_profile(args.pop(0))
else:
config.set_profile("dev")
config.c.async_jobs = True
if args:
config.load_pyconfig(args.pop(0))
config.activate_profile()
bq = config.c.queue
log.debug("Queue: %s", bq)
for qi in bq.read_queue("vcs"):
log.info("Processing job %s", qi.id)
log.debug("Message: %s", qi.message)
qi.run()
qi.done()
def process_queue(args=None):
log.info("Bespin queue worker")
if args is None:
args = sys.argv[1:]
if args:
config.set_profile(args.pop(0))
else:
config.set_profile("dev")
config.c.async_jobs=True
if args:
config.load_config(args.pop(0))
config.activate_profile()
bq = config.c.queue
log.debug("Queue: %s", bq)
for qi in bq.read_queue("vcs"):
log.info("Processing job %s", qi.id)
log.debug("Message: %s", qi.message)
qi.run()
qi.done()
def editbespin(options):
"""Use Bespin to edit Bespin. This will change the given
user's file location to the directory above Bespin, allowing
you to edit Bespin (and any other projects you have
in that directory)."""
if not 'editbespin' in options or not options.editbespin.user:
raise BuildFailure("You must specify a user with -u for this task.")
user = options.editbespin.user
from bespin import config
from bespin import database, filesystem
from sqlalchemy.orm.exc import NoResultFound
config.set_profile("dev")
config.activate_profile()
session = config.c.session_factory()
try:
user = session.query(database.User).filter_by(username=user).one()
except NoResultFound:
raise BuildFailure("I couldn't find %s in the database. Sorry!" %
(user))
location = path.getcwd().parent.abspath()
user.file_location = location
user.recompute_files()
session.commit()
bespinsettings_loc = location / "BespinSettings"
if not bespinsettings_loc.exists():
project = filesystem.get_project(user,
user,
"BespinSettings",
create=True)
project.install_template('usertemplate')
info("User %s set up to access directory %s" % (user, location))
def start_server(args=None):
if args is None:
args = sys.argv[1:]
if args:
mode = args.pop(0)
else:
mode = "dev"
print("Bespin mobwrite worker (mode=" + mode + ")")
config.set_profile(mode)
if args:
config.load_pyconfig(args.pop(0))
if mode == "dev":
config.load_pyconfig("devconfig.py")
config.activate_profile()
app = WSGIMobWrite()
app = db_middleware(app)
serve(app, config.c.mobwrite_server_address, config.c.mobwrite_server_port, use_threadpool=True)
def setup_module(module):
global app
config.set_profile("test")
app = controllers.make_app()
app = BespinTestApp(app)
def setup_module(module):
global app
config.set_profile('test')
app = controllers.make_app()
app = BespinTestApp(app)
logging.basicConfig(level=logging.DEBUG)
def setup_module(module):
config.set_profile("test")
config.activate_profile()
def setup_module(module):
global app
config.set_profile('test')
app = controllers.make_app()
app = TestApp(app)
#
from path import path
from simplejson import loads
from bespin import config, plugins, controllers
from bespin.database import User, Base, EventLog, _get_session, GalleryPlugin
from bespin.filesystem import get_project
from __init__ import BespinTestApp
app = None
plugindir = (path(__file__).dirname() / "plugindir").abspath()
config.set_profile("test")
_original_plugin_path = config.c.plugin_path
def _install_test_plugin_path(name="testplugins"):
config.c.plugin_path = [dict(name=name, path=plugindir,
chop=len(plugindir))]
def setup_module():
global app, app_murdoc
config.set_profile('test')
app = controllers.make_app()
app = BespinTestApp(app)
app_murdoc = controllers.make_app()
app_murdoc = BespinTestApp(app_murdoc)
_install_test_plugin_path()
def setup_module(module):
global app
config.set_profile('test')
app = controllers.make_app()
app = BespinTestApp(app)
logging.basicConfig(level=logging.DEBUG)
def setup_module(module):
global app
config.set_profile('test')
app = controllers.make_app()
app = BespinTestApp(app)
def setup_module(module):
config.set_profile("test")
config.activate_profile()
