コード例 #1
0
def app(tmpdir_factory):
    """Method to create an app for testing."""
    # need to import this late as it might have side effects
    from app import app as app_
    from app import celery

    # need to save old configurations of the app
    # to restore them later upon tear down
    old_url_map = copy.copy(app_.url_map)
    old_view_functions = copy.copy(app_.view_functions)
    app_.testing = True
    app_.debug = False
    old_config = copy.copy(app_.config)

    # set task always eager to true in celery configurations in order to run celery tasks synchronously
    app_.config['task_always_eager'] = True
    celery.conf.update(app_.config)

    # update configuration file path
    global_config = yaml.load(
        open(
            path.abspath(path.dirname(__file__) +
                         "/unittest_data/config.yml")))
    app_.config['system_config'] = global_config

    # update conditions file path
    conditions = yaml.load(
        open(
            path.abspath(
                path.dirname(__file__) + "/unittest_data/conditions.yml")))
    app_.config['conditions'] = conditions

    config = configparser.ConfigParser()
    config.read(
        path.abspath(path.dirname(__file__) + "/unittest_data/config.ini"))
    app_.config['dev_config'] = config

    temp_tasks = tmpdir_factory.mktemp('tasks')
    temp_reports = tmpdir_factory.mktemp('reports')

    # update upload directories path
    app_.config['dev_config']['UPLOADS']['task_dir'] = str(
        temp_tasks)  # path to task_ids file upload
    app_.config['dev_config']['UPLOADS']['report_dir'] = str(
        temp_reports)  # path to non compliant report upload

    # initialize temp database and yield app
    postgresql = Postgresql()
    app_.config['SQLALCHEMY_DATABASE_URI'] = postgresql.url()
    yield app_

    # restore old configs after successful session
    app_.url_map = old_url_map
    app_.view_functions = old_view_functions
    app_.config = old_config
    shutil.rmtree(path=str(temp_tasks))
    shutil.rmtree(path=str(temp_reports))
    postgresql.stop()
コード例 #2
0
class TestDataStoreInitialisePostgres(TestCase):
    def setUp(self):
        self.postgres = None
        try:
            self.postgres = Postgresql(database="test",
                                       host="localhost",
                                       user="******",
                                       port=55527)
        except RuntimeError:
            print("PostgreSQL database couldn't be created! "
                  "Test is skipping.")

    def tearDown(self):
        try:
            self.postgres.stop()
        except AttributeError:
            return

    def test_postgres_initialise(self):
        """Test whether schemas created successfully on PostgresSQL"""
        if self.postgres is None:
            self.skipTest("Postgres is not available. Test is skipping")

        data_store_postgres = DataStore(
            db_username="******",
            db_password="",
            db_host="localhost",
            db_port=55527,
            db_name="test",
        )

        # inspector makes it possible to load lists of schema, table, column
        # information for the sqlalchemy engine
        inspector = inspect(data_store_postgres.engine)
        table_names = inspector.get_table_names()
        schema_names = inspector.get_schema_names()

        # there must be no table, and no schema for datastore at the beginning
        self.assertEqual(len(table_names), 0)
        self.assertNotIn("datastore_schema", schema_names)

        # creating database from schema
        data_store_postgres.initialise()

        inspector = inspect(data_store_postgres.engine)
        table_names = inspector.get_table_names()
        schema_names = inspector.get_schema_names()

        # 11 tables must be created. A few of them tested
        self.assertEqual(len(table_names), 11)
        self.assertIn("Entry", table_names)
        self.assertIn("Platforms", table_names)
        self.assertIn("State", table_names)
        self.assertIn("Datafiles", table_names)
        self.assertIn("Nationalities", table_names)

        # datastore_schema must be created
        self.assertIn("datastore_schema", schema_names)
コード例 #3
0
class TestDatabaseReflection(TestCase):
    def setUp(self):
        self.postgresql = Postgresql()
        self.engine = create_engine(self.postgresql.url())

    def tearDown(self):
        self.postgresql.stop()

    def test_split_table(self):
        assert dbreflect.split_table("staging.incidents") == ("staging",
                                                              "incidents")
        assert dbreflect.split_table("incidents") == (None, "incidents")
        with self.assertRaises(ValueError):
            dbreflect.split_table("blah.staging.incidents")

    def test_table_object(self):
        assert isinstance(dbreflect.table_object("incidents", self.engine),
                          Table)

    def test_reflected_table(self):
        self.engine.execute("create table incidents (col1 varchar)")
        assert dbreflect.reflected_table("incidents", self.engine).exists()

    def test_table_exists(self):
        self.engine.execute("create table incidents (col1 varchar)")
        assert dbreflect.table_exists("incidents", self.engine)
        assert not dbreflect.table_exists("compliments", self.engine)

    def test_table_has_data(self):
        self.engine.execute("create table incidents (col1 varchar)")
        self.engine.execute("create table compliments (col1 varchar)")
        self.engine.execute("insert into compliments values ('good job')")
        assert dbreflect.table_has_data("compliments", self.engine)
        assert not dbreflect.table_has_data("incidents", self.engine)

    def test_table_has_duplicates(self):
        self.engine.execute("create table events (col1 int, col2 int)")
        assert not dbreflect.table_has_duplicates("events", ['col1', 'col2'],
                                                  self.engine)
        self.engine.execute("insert into events values (1,2)")
        self.engine.execute("insert into events values (1,3)")
        assert dbreflect.table_has_duplicates("events", ['col1'], self.engine)
        assert not dbreflect.table_has_duplicates("events", ['col1', 'col2'],
                                                  self.engine)
        self.engine.execute("insert into events values (1,2)")
        assert dbreflect.table_has_duplicates("events", ['col1', 'col2'],
                                              self.engine)

    def test_table_has_column(self):
        self.engine.execute("create table incidents (col1 varchar)")
        assert dbreflect.table_has_column("incidents", "col1", self.engine)
        assert not dbreflect.table_has_column("incidents", "col2", self.engine)

    def test_column_type(self):
        self.engine.execute("create table incidents (col1 varchar)")
        assert dbreflect.column_type("incidents", "col1",
                                     self.engine) == VARCHAR
コード例 #4
0
ファイル: conftest.py プロジェクト: a-wakeel/flask-bp
def app():
    """api fixture"""
    from flask_bp.api import app as app_
    app_.testing = True
    app_.debug = False

    # initialize a temp db instance
    postgresql = Postgresql()
    app_.config['SQLALCHEMY_DATABASE_URI'] = postgresql.url()
    yield app_

    postgresql.stop()
コード例 #5
0
ファイル: conftest.py プロジェクト: seantis/libres
def dsn():
    postgres = Postgresql()

    scheduler = new_test_scheduler(postgres.url())
    scheduler.setup_database()
    scheduler.commit()

    yield postgres.url()

    scheduler.close()

    postgres.stop()
コード例 #6
0
ファイル: testing.py プロジェクト: scott50301/DS-project
class SqlLayer(PloneSandboxLayer):

    default_bases = (PLONE_FIXTURE,)

    class Session(dict):
        def set(self, key, value):
            self[key] = value

    def start_postgres(self):
        self.postgres = Postgresql()
        return self.postgres.url().replace(
            'postgresql://', 'postgresql+psycopg2://')

    def stop_postgres(self):
        self.postgres.stop()

    def init_config(self, dsn):
        config = getConfiguration()
        if not hasattr(config, 'product_config'):
            config.product_config = {}

        config.product_config['seantis.reservation'] = dict(dsn=dsn)

        setConfiguration(config)

    def setUpZope(self, app, configurationContext):

        # Set up sessioning objects
        app.REQUEST['SESSION'] = self.Session()
        ZopeTestCase.utils.setupCoreSessions(app)

        self.init_config(dsn=self.start_postgres())

        import seantis.reservation
        xmlconfig.file(
            'configure.zcml',
            seantis.reservation,
            context=configurationContext
        )
        self.loadZCML(package=seantis.reservation)

    def setUpPloneSite(self, portal):

        quickInstallProduct(portal, 'plone.app.dexterity')
        quickInstallProduct(portal, 'seantis.reservation')
        applyProfile(portal, 'seantis.reservation:default')

    def tearDownZope(self, app):
        z2.uninstallProduct(app, 'seantis.reservation')
        self.stop_postgres()
コード例 #7
0
class TestDatabaseReflection(TestCase):
    def setUp(self):
        self.postgresql = Postgresql()
        self.engine = create_engine(self.postgresql.url())

    def tearDown(self):
        self.postgresql.stop()

    def test_split_table(self):
        assert dbreflect.split_table('staging.incidents') == ('staging',
                                                              'incidents')
        assert dbreflect.split_table('incidents') == (None, 'incidents')
        with self.assertRaises(ValueError):
            dbreflect.split_table('blah.staging.incidents')

    def test_table_object(self):
        assert isinstance(dbreflect.table_object('incidents', self.engine),
                          Table)

    def test_reflected_table(self):
        self.engine.execute('create table incidents (col1 varchar)')
        assert dbreflect.reflected_table('incidents', self.engine).exists()

    def test_table_exists(self):
        self.engine.execute('create table incidents (col1 varchar)')
        assert dbreflect.table_exists('incidents', self.engine)
        assert not dbreflect.table_exists('compliments', self.engine)

    def test_table_has_data(self):
        self.engine.execute('create table incidents (col1 varchar)')
        self.engine.execute('create table compliments (col1 varchar)')
        self.engine.execute('insert into compliments values (\'good job\')')
        assert dbreflect.table_has_data('compliments', self.engine)
        assert not dbreflect.table_has_data('incidents', self.engine)

    def test_table_has_column(self):
        self.engine.execute('create table incidents (col1 varchar)')
        assert dbreflect.table_has_column('incidents', 'col1', self.engine)
        assert not dbreflect.table_has_column('incidents', 'col2', self.engine)

    def test_column_type(self):
        self.engine.execute('create table incidents (col1 varchar)')
        assert dbreflect.column_type('incidents', 'col1',
                                     self.engine) == VARCHAR
コード例 #8
0
def app(mocked_config, tmpdir_factory):
    """Method to create an app for testing."""
    # need to import this late as it might have side effects
    from app import app as app_

    # need to save old configurations of the app
    # to restore them later upon tear down
    old_url_map = copy.copy(app_.url_map)
    old_view_functions = copy.copy(app_.view_functions)
    app_.testing = True
    app_.debug = False
    old_config = copy.copy(app_.config)

    # initialize temp database and yield app
    postgresql = Postgresql()
    dsn = postgresql.dsn()
    # monkey patch database configs
    for setting in ['user', 'password', 'port', 'host', 'database']:
        mocked_config['database'][setting] = dsn.get(setting, '')

    # monkey patch temp dirs
    temp_lists = tmpdir_factory.mktemp('lists')
    mocked_config['lists']['path'] = str(temp_lists)
    temp_uploads = tmpdir_factory.mktemp('uploads')
    mocked_config['global']['upload_directory'] = str(temp_uploads)
    app_.config['drs_config'] = mocked_config
    app_.config['SQLALCHEMY_DATABASE_URI'] = postgresql.url()
    app_.config['DRS_UPLOADS'] = str(temp_uploads)
    app_.config['DRS_LISTS'] = str(temp_lists)
    app_.config['CORE_BASE_URL'] = mocked_config['global']['core_api_v2']
    app_.config['DVS_BASE_URL'] = mocked_config['global']['dvs_api_v1']

    yield app_

    # restore old configs after successful session
    app_.url_map = old_url_map
    app_.view_functions = old_view_functions
    app_.config = old_config
    shutil.rmtree(str(temp_lists))
    shutil.rmtree(str(temp_uploads))
    postgresql.stop()
コード例 #9
0
def app(tmpdir_factory):
    """Method to create an app for testing."""
    # need to import this late as it might have side effects
    from app import app as app_

    # need to save old configurations of the app
    # to restore them later upon tear down
    old_url_map = copy.copy(app_.url_map)
    old_view_functions = copy.copy(app_.view_functions)
    app_.testing = True
    app_.debug = False
    old_config = copy.copy(app_.config)

    # update configuration file path
    global_config = yaml.safe_load(
        open(path.abspath(path.dirname(__file__) + "/testdata/config.yml")))
    app_.config['system_config'] = global_config

    # update configuration file path
    config = configparser.ConfigParser()
    config.read(
        path.abspath(path.dirname(__file__) + "/testdata/config_test.ini"))

    temp_lists = tmpdir_factory.mktemp('uploads')

    # update upload directories path
    app_.config['system_config'] = config
    app_.config['system_config']['UPLOADS']['list_dir'] = str(temp_lists)

    # initialize temp database and yield app
    postgresql = Postgresql()
    app_.config['SQLALCHEMY_DATABASE_URI'] = postgresql.url()
    yield app_

    # restore old configs after successful session
    app_.url_map = old_url_map
    app_.view_functions = old_view_functions
    app_.config = old_config
    shutil.rmtree(path=str(temp_lists))
    postgresql.stop()
コード例 #10
0
def postgresql(request):
    psql = Postgresql()

    yield psql
    psql.stop()
コード例 #11
0
ファイル: run.py プロジェクト: seantis/libres
        scheduler.rollback()
        raise

    return json.dumps(
        {'status': 'success', 'message': 'A reservation has been made'}
    )


@app.route('/')
def index():
    return render_template('index.html')


if __name__ == '__main__':

    postgresql = Postgresql()

    try:
        context = libres.registry.register_context('flask-exmaple')
        context.set_setting('dsn', postgresql.url())
        scheduler = libres.new_scheduler(
            context, 'Test Scheduler', timezone='Europe/Zurich'
        )
        scheduler.setup_database()
        scheduler.commit()

        app.run(debug=True)

    finally:
        postgresql.stop()