Beispiel #1
0
    def test_run_not_enough_conns_in_scope(self):
        # Arrange
        conn_scope = {'conn_a': self.conn1} # We give too few connections
        reinterpreter = Reinterpreter(program=self.program,
                                      conn_scope=conn_scope,
                                      program_is_path=False)

        # Act/Assert
        with self.assertRaises(StopIteration):
            scope = reinterpreter.run() # Should throw an StopIteration exception
Beispiel #2
0
    def setUp(self):
        BASE_DIR = os.path.dirname(os.path.abspath('__file__'))
        db_path_a = os.path.join(BASE_DIR, "a.db")
        db_path_b = os.path.join(BASE_DIR, "b.db")
        self.conn1 = sqlite3.Connection(db_path_a)
        self.conn2 = sqlite3.Connection(db_path_b)
        self.conn_scope = {'conn_a': self.conn1, 'conn_b': self.conn2}
        self.program = \
"""import pygrametl
from pygrametl.datasources import SQLSource
from pygrametl.tables import Dimension, FactTable
import sqlite3

input_conn = sqlite3.connect('input.db')
output_conn = sqlite3.connect('output.db')

input_src = SQLSource(input_conn, query='SELECT * dim1')
output_wrapper = pygrametl.ConnectionWrapper(connection=output_conn)

dim1 = Dimension(
    name='dim1',
    key='key1',
    attributes=['attr1', 'attr2']
)

dim2 = Dimension(
    name='dim2',
    key='key2',
    attributes=['attr3', 'attr4']
)

ft1 = FactTable(
    name='ft1',
    keyrefs=['key1',]
)

input_conn.close()
output_conn.close()
"""
        self.reinterpreter = Reinterpreter(program=self.program,
                                           conn_scope=self.conn_scope,
                                           program_is_path=False)
Beispiel #3
0
"""


# Vi laver et Dict hvor vi mapper en string til vores connection. Dette dict skal
# være ordered efter den række følge som vores connections blive brugt af
# datasources i vores pygrametl program. Dette dict blive brugt som et scope i
# ens pygrametl program, og gør at vi kan bruge disse, i stedet for hardcodede.
# Værdien af strengen skal bare være noget som man ikke allerede brugere som et
# variable navn i ens pygrametl program.
scope = {'conn_a': conn_dw, 'conn_b': conn_input_1, 'conn_c': conn_input_2}


# Vi giver programmet og scopet til vores reinterpreter. Reinterpreteren vil
# eksekvere vores pygrametl kode, men med pointere til de connections vi gerne
# vil have at den skal bruge.
reint = Reinterpreter(program=program, conn_scope=scope, program_is_path=False)

# Vi kalder run på reinterpreter, dette eksekvere pygrametl koden som vi gerne
# ville have den. Og returnere et dictionary af SQLSource objekter, en får hver
# Dimension eller FactTable instantiering pygrametl koden. Dette gøres for at
# brugeren nu nemt kan give de forskellige tables i deres DW til predicates.
# Dictets keys er navne på tabellerne som indeholde den pågældende dimension/ft
dw_tables = reint.run()

# Vi henter dim1 ud fra dw_tables
dim1 = dw_tables['dim1']

# Vi tester om der er duplikerede tubler i denne tabel
dubpred = DublicatePredicate(dim1)
dubpred.run()
Beispiel #4
0
import os.path

BASE_DIR = os.path.dirname(os.path.abspath('__file__'))
DB = os.path.join(BASE_DIR, 'brandtest.db')
DW = os.path.join(BASE_DIR, 'dwtest.db')
CSV = os.path.join(BASE_DIR, 'weapontest.csv')


program_path = './brand_sample.py'

setup_input_db(DB)
setup_out_dw(DW)
# setup_input_csv(CSV)

db_conn = sqlite3.connect(DB)
dw_conn = sqlite3.connect(DW)


#csv_conn = sqlite3.connect(CSV)

conn_dict = {'conn0': db_conn, 'conn1': dw_conn}

try:
    tc = Reinterpreter(program=program_path, conn_scope=conn_dict, program_is_path=True)

    scope = tc.run()
finally:
    db_conn.close()
    dw_conn.close()
    pass
Beispiel #5
0
""" An example of how to run a test
"""

__author__ = 'Mathias Claus Jensen'

from reinterpreter import Reinterpreter
import sqlite3

program_path = 'sample_program.py'

conn1 = sqlite3.connect('a.db')
conn2 = sqlite3.connect('b.db')


conn_dict  = {'conn1': conn1, 'conn2': conn2}
    
tc = Reinterpreter(program=program_path, conn_scope=conn_dict, program_is_path=True)
scope = tc.run()


def close():
    conn1.close()
    conn2.close()

globals().update({'close':close})
globals().update(scope)