def test_base_db_instance(patch):
patch.init(SqliteDatabase)
patch.object(db_url, 'parse')
result = Base.db_instance('url')
db_url.parse.assert_called_with('url')
db_url.parse().pop.assert_called_with('database')
SqliteDatabase.__init__.assert_called_with(db_url.parse().pop())
assert isinstance(result, SqliteDatabase)
def test_db_url_parse(self):
cfg = parse('mysql://*****:*****@hst:123/db')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['passwd'], 'pwd')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
cfg = parse('postgresql://*****:*****@hst/db')
self.assertEqual(cfg['password'], 'pwd')
def test_db_url_quoted_password(self):
# By default, the password is not unescaped.
cfg = parse('mysql://*****:*****@hst:123/db')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['passwd'], 'pwd%23%20')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
cfg = parse('mysql://*****:*****@hst:123/db', unquote_password=True)
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['passwd'], 'pwd# ')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
def test_db_url_quoted_password(self):
# By default, the password is not unescaped.
cfg = parse('mysql://*****:*****@hst:123/db')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['passwd'], 'pwd%23%20')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
cfg = parse('mysql://*****:*****@hst:123/db', unquote_password=True)
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['passwd'], 'pwd# ')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
def mysql_uri():
db = parse("mysql://*****:*****@192.168.1.106/irm")
print(dir(db))
print(db)
# print(db.hostname, db.port, db.username, db.password, db.path)
print(db.get('database'))
def test_base_db_instance_postgres(patch):
patch.init(PostgresqlDatabase)
patch.object(db_url, 'parse')
result = Base.db_instance('postgres')
db_str = db_url.parse()
PostgresqlDatabase.__init__.assert_called_with(db_str.pop(), **db_str)
assert isinstance(result, PostgresqlDatabase)
def db_instance(url, **kwargs):
"""
Create the correct database instance from the url
"""
dictionary = db_url.parse(url)
name = dictionary.pop('database')
if url.startswith('postgres'):
return PostgresqlDatabase(name, **dictionary)
return SqliteDatabase(name, **kwargs)
def create_database(app: App) -> None:
config = get_config(app)
database = peewee_asyncext.PooledPostgresqlExtDatabase(
**parse(config.postgres_url))
database_proxy.initialize(database)
app.ctx['database'] = database_proxy
objects = peewee_async.Manager(database_proxy)
database.set_allow_sync(False)
app.ctx['objects'] = objects
def test_db_url_parse(self):
cfg = parse('mysql://*****:*****@hst:123/db')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['passwd'], 'pwd')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
cfg = parse('postgresql://*****:*****@hst/db')
self.assertEqual(cfg['password'], 'pwd')
cfg = parse('mysql+pool://usr:pwd@hst:123/db'
'?max_connections=42&stale_timeout=8001')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['password'], 'pwd')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
self.assertEqual(cfg['max_connections'], '42')
self.assertEqual(cfg['stale_timeout'], '8001')
def _get_driver(self, dburi):
"""assigns eve.data.driver based on config.DATABASE_URI
Override for any atypical db needs
"""
# NOTE: if there's an uncaptured db exception and rollback doesn't
# happen then the site is down until restart, could do autorollback=True?
parsed = db_url.urlparse(dburi)
class RetryDB(RetryOperationalError, db_url.schemes[parsed.scheme]):
pass
return RetryDB(**db_url.parse(dburi))
def test_db_url_parse(self):
cfg = parse('mysql://*****:*****@hst:123/db')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['passwd'], 'pwd')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
cfg = parse('postgresql://*****:*****@hst/db')
self.assertEqual(cfg['password'], 'pwd')
cfg = parse('mysql+pool://usr:pwd@hst:123/db'
'?max_connections=42&stale_timeout=8001.2&zai=&baz=3.4.5'
'&boolz=false')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['password'], 'pwd')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
self.assertEqual(cfg['max_connections'], 42)
self.assertEqual(cfg['stale_timeout'], 8001.2)
self.assertEqual(cfg['zai'], '')
self.assertEqual(cfg['baz'], '3.4.5')
self.assertEqual(cfg['boolz'], False)
def test_db_url_parse(self):
cfg = parse('mysql://*****:*****@hst:123/db')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['passwd'], 'pwd')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
cfg = parse('postgresql://*****:*****@hst/db')
self.assertEqual(cfg['password'], 'pwd')
cfg = parse('mysql+pool://usr:pwd@hst:123/db'
'?max_connections=42&stale_timeout=8001.2&zai=&baz=3.4.5'
'&boolz=false')
self.assertEqual(cfg['user'], 'usr')
self.assertEqual(cfg['password'], 'pwd')
self.assertEqual(cfg['host'], 'hst')
self.assertEqual(cfg['database'], 'db')
self.assertEqual(cfg['port'], 123)
self.assertEqual(cfg['max_connections'], 42)
self.assertEqual(cfg['stale_timeout'], 8001.2)
self.assertEqual(cfg['zai'], '')
self.assertEqual(cfg['baz'], '3.4.5')
self.assertEqual(cfg['boolz'], False)
def shell_db():
db_type = settings.DATABASE.split(':')[0]
params = parse(settings.DATABASE)
if db_type.startswith('postgres'):
command = 'psql'
else:
sp.run(('sqlite3', params['database']))
return
env = os.environ.copy()
command += ' --host={host} --port={port}'.format(**params)
command = command.format(**params).split()
if params.get('user'):
command.append('--user={user}'.format(**params))
if params.get('password'):
env['PGPASSWORD'] = params['password']
command.append(params['database'])
sp.run(command, env=env)
def _database(self, DBURL=None):
"""
_database is used to create a async connection with db.
Parameters:
DBURL (str): - batabase url
Return:
object: - db connection object
dburl's example:
postgresql://user:password@ip:port/dbname
mysql://user:passwd@ip:port/dbname
mysql+pool://user:passwd@ip:port/dbname?max_connections=20
postgresql+pool://user:passwd@ip:port/dbname?max_connections=20
postgresqlext://user:passwd@ip:port/dbname
postgresqlext+pool://user:passwd@ip:port/dbname?max_connections=20
"""
TYPES = {
"postgresql": PostgresqlDatabase,
"mysql": MySQLDatabase,
"postgresql+pool": PooledPostgresqlDatabase,
"mysql+pool": PooledMySQLDatabase,
"postgresqlext": PostgresqlDatabase,
"postgresqlext+pool": PooledPostgresqlExtDatabase,
}
def _raise():
raise AttributeError("unknow db type")
if DBURL:
if DBURL.find("://") < 0:
raise AttributeError("you need to input a database url")
else:
dbtype = DBURL.split("://")[0]
dbinfo = parse(DBURL)
if dbinfo.get("passwd"):
dbinfo["password"] = dbinfo["passwd"]
del dbinfo["passwd"]
return TYPES.get(dbtype, lambda **ks: _raise())(**dbinfo)
import peewee_async
from aiohttp import web
from playhouse.db_url import parse
from app import settings
from writer.handlers import WriterView
db_param = parse(settings.DATABASE_URL)
db = peewee_async.PostgresqlDatabase(**db_param)
app = web.Application()
app.db = db
app.objects = peewee_async.Manager(db)
app.router.add_route('*', '/', WriterView)
import datetime
import markdown
from peewee import (MySQLDatabase, Model, IntegerField, CharField, TextField,
DateTimeField, AutoField, ForeignKeyField)
from playhouse import db_url
import click
from flask.cli import with_appcontext
import boto3
APP_NAME = os.environ['APP_NAME']
ENV_NAME = os.environ['ENV_NAME']
ssm = boto3.client('ssm')
response = ssm.get_parameter(Name=f'/{APP_NAME}/{ENV_NAME}/mysqldb')
params = db_url.parse(response['Parameter']['Value'])
database = MySQLDatabase(**params)
class BaseModel(Model):
class Meta:
database = database
class User(BaseModel):
id = AutoField()
username = CharField(unique=True)
password = CharField()
class Post(BaseModel):
"""
General fixtures for Tornado application testing
"""
import os
from subprocess import Popen
import pytest
from peewee_migrate import Router
from playhouse.db_url import parse
from project.app import application
from project.application.models import db
from project.config.settings import base_dir, db_url
db_param = parse(db_url)
TEST_DB = db_param['database']
@pytest.fixture(scope='session')
def app():
return application
@pytest.fixture(scope='session', autouse=True)
def async_db(request):
"""
Фикстура для асинхронного взаимодействия с базой PostgreSQL через PeeWee ORM
"""
# Создание базы
process = Popen(['createdb', TEST_DB])
from urllib.parse import urlparse
from playhouse.db_url import parse
def mysql_uri():
db = parse("mysql://*****:*****@192.168.1.106/irm")
print(dir(db))
print(db)
# print(db.hostname, db.port, db.username, db.password, db.path)
print(db.get('database'))
def redis_uri():
str = "redis://192.168.1.106:6379/1"
uri = parse(str)
print(uri)
if False:
db2 = parse('mysql://*****:*****@meeting.test.test.com:3307/test')
print(db2)
print(type(db2.get('port')))
print(type(db2.get('port', 3306)))
print(db2.get('port', 3306))
if __name__ == "__main__":
redis_uri()
def redis_uri():
str = "redis://192.168.1.106:6379/1"
uri = parse(str)
print(uri)
def test_base_db_instance_extra_options(patch):
patch.init(SqliteDatabase)
patch.object(db_url, 'parse')
Base.db_instance('url', autocommit=False)
pop = db_url.parse().pop()
SqliteDatabase.__init__.assert_called_with(pop, autocommit=False)
"""
General fixtures for Tornado application testing.
"""
import os
import peewee_async
import psycopg2
import pytest
from playhouse.db_url import parse
from tornado.ioloop import IOLoop
from tornado.web import Application
IOLoop.configure('tornado.platform.asyncio.AsyncIOMainLoop')
db_param = parse(os.environ.get('DATABASE_URL'))
TEST_DB = db_param.get('database', 'testdb')
TEST_USER = db_param.get('user', 'postgres')
TEST_PWD = db_param.get('password', '')
TEST_HOST = db_param.get('host', 'localhost')
TEST_PORT = db_param.get('port', 5432)
db = peewee_async.PooledPostgresqlDatabase(**db_param)
db.allow_sync = False
@pytest.fixture(scope='session')
def app(async_db):
"""
Application fixture.
Required by pytest-tornado.
