def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(
connection_string=self.connection_string, debug=False)
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
self.memory_database = MemoryDatabase()
self.memory_database.set_series_service(self.series_service)
self.session = self.memory_database.series_service._session_factory.get_session(
)
self.series = test_util.add_series_bulk_data(self.session)
#assert len(self.series.data_values) == 100
self.edit_service = EditService(1, connection=self.memory_database)
"""
@pytest.fixture(scope="class", autouse=True)
def build_db(self):
"""
#Builds an empty sqlite (in-memory) database for testing
#:return: None
"""
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(self.connection_string,
debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
def worker(cls, dispatcher):
"""
The worker creates a TaskProcessor Object
:return:
"""
while True:
arg = dispatcher.getTask()
task_type = arg[0] #(task_type, (arg1, arg2))
task = arg[1]
result = arg
if task_type == "Probability":
result = Probability(task)
if task_type == "BoxWhisker":
result = BoxWhisker(task[0], task[1])
if task_type == "Summary":
result = Statistics(task)
if task_type == "InitEditValues":
connection = SeriesService("sqlite:///:memory:")
df = task[1]
logger.debug("Load series from db")
df.to_sql(name="DataValues", con=connection._session_factory.engine, flavor='sqlite', index = False, chunksize = 10000)
logger.debug("done loading database")
result = connection
if task_type == "UpdateEditDF":
connection = task[1]
result = connection.get_all_values_df()
result = (task_type, result)
# save the result
dispatcher.putResult(result)
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(self.connection_string,
debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
"""
@pytest.fixture(scope="class", autouse=True)
def build_db(self):
"""
#Builds an empty sqlite (in-memory) database for testing
#:return: None
"""
def __init__(self, taskserver=None):
self.editLoaded = False
self.df = None
# Series_Service handles remote database
self.series_service = None
# Memory_service handles in memory database
self.mem_service = SeriesService("sqlite:///:memory:")
# TODO clean up closing of program
# if taskserver is None:
#numproc = cpu_count()
#self.taskserver = TaskServerMP(numproc=numproc)
#else:
self.taskserver = taskserver
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(connection_string=self.connection_string, debug=False)
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
self.memory_database = MemoryDatabase()
self.memory_database.set_series_service(self.series_service)
self.session = self.memory_database.series_service._session_factory.get_session()
self.series = test_util.add_series_bulk_data(self.session)
#assert len(self.series.data_values) == 100
self.edit_service =EditService(1, connection= self.memory_database)
"""
@pytest.fixture(scope="class", autouse=True)
def build_db(self):
"""
#Builds an empty sqlite (in-memory) database for testing
#:return: None
"""
def worker(cls, dispatcher):
"""
The worker creates a TaskProcessor Object
:return:
"""
while True:
arg = dispatcher.getTask()
task_type = arg[0] #(task_type, (arg1, arg2))
task = arg[1]
result = arg
if task_type == "Probability":
result = Probability(task)
if task_type == "BoxWhisker":
result = BoxWhisker(task[0], task[1])
if task_type == "Summary":
result = Statistics(task)
if task_type == "InitEditValues":
connection = SeriesService("sqlite:///:memory:")
df = task[1]
logger.debug("Load series from db")
df.to_sql(name="DataValues",
con=connection._session_factory.engine,
flavor='sqlite',
index=False,
chunksize=10000)
logger.debug("done loading database")
result = connection
if task_type == "UpdateEditDF":
connection = task[1]
result = connection.get_all_values_df()
result = (task_type, result)
# save the result
dispatcher.putResult(result)
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(
connection_string=self.connection_string, debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
self.memory_db = MemoryDatabase()
self.memory_db.set_series_service(self.series_service)
self.series = test_util.add_series(self.session)
self.memory_db.initEditValues(self.series.id)
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(self.connection_string, debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
"""
@pytest.fixture(scope="class", autouse=True)
def build_db(self):
"""
#Builds an empty sqlite (in-memory) database for testing
#:return: None
"""
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(
connection_string=self.connection_string, debug=False)
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
self.memory_database = MemoryDatabase()
self.memory_database.set_series_service(self.series_service)
self.session = self.memory_database.series_service._session_factory.get_session(
)
self.series = test_util.add_series_bulk_data(self.session)
#assert len(self.series.data_values) == 100
self.edit_service = EditService(1, connection=self.memory_database)
def setup(self):
self.app = wx.App()
self.frame = wx.Frame(None)
self.pltProb = plotProbability.plotProb(id=wxID_PAGEPROB,
name='pltProb',
parent=self.frame,
pos=wx.Point(0, 0),
size=wx.Size(605, 458),
style=wx.TAB_TRAVERSAL)
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(
connection_string=self.connection_string, debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
build_db(engine)
self.memory_db = MemoryDatabase()
self.memory_db.set_series_service(self.series_service)
self.series = add_series(self.session)
print "Series: ", self.series
self.memory_db.initEditValues(self.series.id)
class TestSeriesService:
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(self.connection_string,
debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
def test_get_db_version(self):
version = test_util.add_version(self.session)
db_version = self.series_service.get_db_version()
assert version.version_number == db_version
def test_get_all_sites_empty(self):
sites = self.series_service.get_used_sites()
#assert len(sites) == 0
assert sites is None
def test_create_qualifier(self):
qual = Qualifier()
qual.code = "ABC123"
qual.description = "This is a test"
self.series_service.create_qualifier_by_qual(qual)
assert qual.id is not None
def test_get_qualifiers(self):
assert self.series_service.get_all_qualifiers() == []
qual = self.series_service.create_qualifier("ABC123", "This is a test")
db_qual = self.series_service.get_all_qualifiers()[0]
assert qual.id == db_qual.id
def test_get_all_sites(self):
assert self.series_service.get_used_sites() is None
site = test_util.add_site(self.session)
sites = self.series_service.get_used_sites()
assert sites is None
if isinstance(sites, list) and len(sites) > 0:
assert site.code == sites[0].code
series = test_util.add_series(self.session)
site = series.site
sites = self.series_service.get_used_sites()
assert len(sites) == 1
if isinstance(sites, list) and len(sites) > 0:
assert site.code == sites[0].code
def test_get_site_by_id_fail(self):
assert self.series_service.get_site_by_id(0) == None
site = test_util.add_site(self.session)
db_site = self.series_service.get_site_by_id(10)
assert db_site == None
def test_get_site_by_id(self):
site = test_util.add_site(self.session)
db_site = self.series_service.get_site_by_id(site.id)
assert db_site != None
assert site.code == db_site.code
def test_get_all_variables(self):
assert self.series_service.get_all_variables() == []
variable = test_util.add_variable(self.session)
variables = self.series_service.get_all_variables()
assert len(variables) == 1
assert variable.code == variables[0].code
def test_get_variable_by_id(self):
assert self.series_service.get_variable_by_id(10) == None
variable = test_util.add_variable(self.session)
db_var = self.series_service.get_variable_by_id(variable.id)
assert db_var != None
assert db_var.code == variable.code
def test_get_variables_by_site_code(self):
assert self.series_service.get_variables_by_site_code('ABC123') == []
series = test_util.add_series(self.session)
variable = series.variable
db_variables = self.series_service.get_variables_by_site_code(
series.site_code)
assert db_variables != None
assert variable.code == db_variables[0].code
def test_get_all_units(self):
assert self.series_service.get_all_units() == []
unit = test_util.add_unit(self.session)
units = self.series_service.get_all_units()
assert len(units) == 1
assert unit.name == units[0].name
def test_get_unit_by_name(self):
assert self.series_service.get_unit_by_name("FAIL") == None
unit = test_util.add_unit(self.session)
db_unit = self.series_service.get_unit_by_name(unit.name)
assert unit.id == db_unit.id
def test_get_unit_by_id(self):
assert self.series_service.get_unit_by_id(10) == None
unit = test_util.add_unit(self.session)
db_unit = self.series_service.get_unit_by_id(unit.id)
assert unit.name == db_unit.name
def test_get_all_series(self):
assert self.series_service.get_all_series() == []
series = test_util.add_series(self.session)
all_series = self.series_service.get_all_series()
assert all_series != []
assert series.id == all_series[0].id
def test_get_series_by_id(self):
assert self.series_service.get_series_by_id(10) == None
series = test_util.add_series(self.session)
db_series = self.series_service.get_series_by_id(series.id)
assert series.id == db_series.id
def test_get_series_by_id_quint(self):
assert self.series_service.get_series_by_id_quint(10, 10, 10, 10,
10) == None
series = test_util.add_series(self.session)
db_series = self.series_service.get_series_by_id_quint(
series.site_id, series.variable_id, series.method_id,
series.source_id, series.quality_control_level_id)
assert series.id == db_series.id
def test_series_exists(self):
assert self.series_service.series_exists_quint(10, 10, 10, 10,
10) == False
series = test_util.add_series(self.session)
site_id = series.site_id
var_id = series.variable_id
method_id = series.method_id
source_id = series.source_id
qcl_id = series.quality_control_level_id
assert self.series_service.series_exists_quint(site_id, var_id,
method_id, source_id,
qcl_id) == True
'''
def test_save_series(self):
series = Series()
site = test_util.add_site(self.session)
variable = test_util.add_variable(self.session)
method = test_util.add_method(self.session)
source = test_util.add_source(self.session)
qcl = test_util.add_qcl(self.session)
series.site_id = site.id
series.variable_id = variable.id
series.method_id = method.id
series.source_id = source.id
series.quality_control_level_id = qcl.id
dvs = []
for val in range(10):
dv = DataValue()
dv.data_value = val
dv.site_id = site.id
dv.variable_id = variable.id
dv.method_id = method.id
dv.source_id = source.id
dv.quality_control_level_id = qcl.id
dvs.append(dv)
print series.variable_code
assert self.series_service.save_series(series)
assert self.series_service.series_exists(site.id, variable.id, method.id, source.id, qcl.id)
assert not self.series_service.save_series(series)
'''
def test_get_data_value_by_id(self):
assert self.series_service.get_data_value_by_id(10) == None
data_values = test_util.add_series(self.session).data_values
dv = data_values[0]
db_dv = self.series_service.get_data_value_by_id(dv.id)
assert dv.data_value == db_dv.data_value
def test_get_qcl_by_id(self):
assert self.series_service.get_qcl_by_id(10) == None
qcl = test_util.add_qcl(self.session)
db_qcl = self.series_service.get_qcl_by_id(qcl.id)
assert qcl.code == db_qcl.code
def test_get_all_qcls(self):
assert self.series_service.get_all_qcls() == []
qcl = test_util.add_qcl(self.session)
all_qcls = self.series_service.get_all_qcls()
assert len(all_qcls) == 1
assert qcl.id == all_qcls[0].id
def test_get_all_methods(self):
assert self.series_service.get_all_methods() == []
method = test_util.add_method(self.session)
all_methods = self.series_service.get_all_methods()
assert len(all_methods) == 1
assert method.id == all_methods[0].id
def test_get_method_by_id(self):
assert self.series_service.get_method_by_id(10) == None
method = test_util.add_method(self.session)
db_method = self.series_service.get_method_by_id(method.id)
assert method.description == db_method.description
def test_delete_dvs(self):
series = test_util.add_series(self.session)
dvs = series.data_values
subset = dvs[:5]
self.series_service.delete_dvs([x.id for x in subset])
assert self.series_service.get_data_value_by_id(subset[0].id) == None
series = self.series_service.get_series_by_id(series.id) # Reload
assert len(series.data_values) == 5
def test_update_dvs(self):
series = test_util.add_series(self.session)
dvs = series.data_values
subset = dvs[:5]
for i in range(len(subset)):
subset[i].data_value = 100
self.series_service.update_dvs(subset)
series = self.series_service.get_series_by_id(series.id)
assert series.data_values[0].data_value == 100
def test_create_new_series(self):
site = test_util.add_site(self.session)
variable = test_util.add_variable(self.session)
method = test_util.add_method(self.session)
source = test_util.add_source(self.session)
qcl = test_util.add_qcl(self.session)
dvs = []
for val in range(10):
dv = DataValue()
dv.data_value = val
dv.site_id = site.id
dv.variable_id = variable.id
dv.method_id = method.id
dv.source_id = source.id
dv.quality_control_level_id = qcl.id
dvs.append(dv)
series = self.series_service.create_new_series(dvs, site.id,
variable.id, method.id,
source.id, qcl.id)
assert series != None
assert len(series.data_values) == 10
assert series.site_id == site.id
assert series.variable_id == variable.id
def test_update_series(self):
series = test_util.add_series(self.session)
series.site_code = "NEW"
series.variable_code = "NEW"
self.series_service.update_series(series)
series = self.series_service.get_series_by_id(series.id)
assert series.site_code == "NEW"
assert series.variable_code == "NEW"
def test_create_method(self):
description = "This tests creating a method"
link = "http://www.example.com"
method = self.series_service.create_method(description, link)
assert method.id != None
assert method.description == description
assert method.link == link
def test_create_variable(self):
unit = test_util.add_unit(self.session)
variable = self.series_service.create_variable(
"Code",
"Name",
"Speciation",
unit.id,
"SampleMedium",
"ValueType",
True, # is_regular
5.0, # time_support
unit.id, # time_unit_id
"DataType",
"GeneralCategory",
-999.0) # no_data_value
assert variable.id != None
assert variable.code == "Code"
assert variable.variable_unit_id == unit.id
def test_create_qcl(self):
qcl = self.series_service.create_qcl("Code", "Definition",
"Explanation")
assert qcl.id != None
assert qcl.code == "Code"
def test_delete_series(self):
series = test_util.add_series(self.session)
assert self.series_service.get_series_by_id(series.id) != None
self.series_service.delete_series(series)
assert self.series_service.get_series_by_id(series.id) == None
def test_qcl_exists(self):
qcl = test_util.add_qcl(self.session)
assert self.series_service.qcl_exists(qcl) == True
qcl.code = "00000"
qcl.definition = "A new definition"
assert self.series_service.qcl_exists(qcl) == False
def test_method_exists(self):
method = test_util.add_method(self.session)
assert self.series_service.method_exists(method) == True
method.description = "A new description"
assert self.series_service.method_exists(method) == False
def test_variable_exists(self):
variable = test_util.add_variable(self.session)
assert self.series_service.variable_exists(variable)
variable.code = "00000"
variable.name = "A new name"
assert not self.series_service.variable_exists(variable)
class TestSeriesService:
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(self.connection_string, debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
"""
@pytest.fixture(scope="class", autouse=True)
def build_db(self):
"""
#Builds an empty sqlite (in-memory) database for testing
#:return: None
"""
# path to the ddl script for building the database
ddlpath= abspath(join(dirname(__file__), 'data/empty.sql'))
# create and empty sqlite database for testing
db = dbconnection.createConnection('sqlite', ':memory:')
# read the ddl script and remove the first (BEGIN TRANSACTION) and last (COMMIT) lines
ddl = open(ddlpath, 'r').read()
ddl = ddl.replace('BEGIN TRANSACTION;','')
ddl = ddl.replace('COMMIT;','')
# execute each statement to build the odm2 database
for line in ddl.split(');')[:-1]:
try:
db.engine.execute(line + ');')
except Exception as e:
print e
self.write = CreateODM2(db)
self.engine= db.engine
globals['write'] = self.write
globals['engine'] = self.engine
globals['db'] = db
# return self.write, self.engine
def setup(self):
self.writer = globals['write']
self.engine = globals['engine']
self.db = globals['db']
"""
def test_get_db_version(self):
version = test_util.add_version(self.session)
db_version = self.series_service.get_db_version()
assert version.version_number == db_version
def test_get_all_sites_empty(self):
sites = self.series_service.get_used_sites()
#assert len(sites) == 0
assert sites is None
def test_create_qualifier(self):
qual = Qualifier()
qual.code = "ABC123"
qual.description = "This is a test"
self.series_service.create_qualifier_by_qual(qual)
assert qual.id is not None
def test_get_qualifier_by_code(self):
assert self.series_service.get_all_qualifiers() == []
qual= self.series_service.create_qualifier("ABC123","This is a test")
db_qual = self.series_service.get_qualifier_by_code("ABC123")
assert qual.id == db_qual.id
def test_get_qualifiers(self):
assert self.series_service.get_all_qualifiers() == []
qual= self.series_service.create_qualifier("ABC123","This is a test")
db_qual = self.series_service.get_all_qualifiers()[0]
assert qual.id == db_qual.id
def test_get_all_sites(self):
assert self.series_service.get_used_sites() is None
site = test_util.add_site(self.session)
sites = self.series_service.get_used_sites()
assert sites is None
if isinstance(sites, list) and len(sites) > 0:
assert site.code == sites[0].code
series = test_util.add_series(self.session)
site = series.site
sites = self.series_service.get_used_sites()
assert len(sites) == 1
if isinstance(sites, list) and len(sites) > 0:
assert site.code == sites[0].code
def test_get_site_by_id_fail(self):
assert self.series_service.get_site_by_id(0) == None
site = test_util.add_site(self.session)
db_site = self.series_service.get_site_by_id(10)
assert db_site == None
def test_get_site_by_id(self):
site = test_util.add_site(self.session)
db_site = self.series_service.get_site_by_id(site.id)
assert db_site != None
assert site.code == db_site.code
def test_get_all_variables(self):
assert self.series_service.get_all_variables() == []
variable = test_util.add_variable(self.session)
variables = self.series_service.get_all_variables()
assert len(variables) == 1
assert variable.code == variables[0].code
def test_get_variable_by_id(self):
assert self.series_service.get_variable_by_id(10) == None
variable = test_util.add_variable(self.session)
db_var = self.series_service.get_variable_by_id(variable.id)
assert db_var != None
assert db_var.code == variable.code
def test_get_variables_by_site_code(self):
assert self.series_service.get_variables_by_site_code('ABC123') == []
series = test_util.add_series(self.session)
variable = series.variable
db_variables = self.series_service.get_variables_by_site_code(series.site_code)
assert db_variables != None
assert variable.code == db_variables[0].code
def test_get_all_units(self):
assert self.series_service.get_all_units() == []
unit = test_util.add_unit(self.session)
units = self.series_service.get_all_units()
assert len(units) == 1
assert unit.name == units[0].name
def test_get_unit_by_name(self):
assert self.series_service.get_unit_by_name("FAIL") == None
unit = test_util.add_unit(self.session)
db_unit = self.series_service.get_unit_by_name(unit.name)
assert unit.id == db_unit.id
def test_get_unit_by_id(self):
assert self.series_service.get_unit_by_id(10) == None
unit = test_util.add_unit(self.session)
db_unit = self.series_service.get_unit_by_id(unit.id)
assert unit.name == db_unit.name
def test_get_all_series(self):
assert self.series_service.get_all_series() == []
series = test_util.add_series(self.session)
all_series = self.series_service.get_all_series()
assert all_series != []
assert series.id == all_series[0].id
def test_get_series_by_id(self):
assert self.series_service.get_series_by_id(10) == None
series = test_util.add_series(self.session)
db_series = self.series_service.get_series_by_id(series.id)
assert series.id == db_series.id
def test_get_series_by_id_quint(self):
assert self.series_service.get_series_by_id_quint(10, 10, 10, 10, 10) == None
series = test_util.add_series(self.session)
db_series = self.series_service.get_series_by_id_quint(series.site_id, series.variable_id, series.method_id,
series.source_id, series.quality_control_level_id)
assert series.id == db_series.id
def test_series_exists(self):
assert self.series_service.series_exists_quint(10, 10, 10, 10, 10) == False
series = test_util.add_series(self.session)
site_id = series.site_id
var_id = series.variable_id
method_id = series.method_id
source_id = series.source_id
qcl_id = series.quality_control_level_id
assert self.series_service.series_exists_quint(site_id, var_id, method_id, source_id, qcl_id) == True
'''
def test_save_series(self):
series = Series()
site = test_util.add_site(self.session)
variable = test_util.add_variable(self.session)
method = test_util.add_method(self.session)
source = test_util.add_source(self.session)
qcl = test_util.add_qcl(self.session)
series.site_id = site.id
series.variable_id = variable.id
series.method_id = method.id
series.source_id = source.id
series.quality_control_level_id = qcl.id
dvs = []
for val in range(10):
dv = DataValue()
dv.data_value = val
dv.site_id = site.id
dv.variable_id = variable.id
dv.method_id = method.id
dv.source_id = source.id
dv.quality_control_level_id = qcl.id
dvs.append(dv)
print series.variable_code
assert self.series_service.save_series(series)
assert self.series_service.series_exists(site.id, variable.id, method.id, source.id, qcl.id)
assert not self.series_service.save_series(series)
'''
def test_get_data_value_by_id(self):
assert self.series_service.get_data_value_by_id(10) == None
data_values = test_util.add_series(self.session).data_values
dv = data_values[0]
db_dv = self.series_service.get_data_value_by_id(dv.id)
assert dv.data_value == db_dv.data_value
def test_get_qcl_by_id(self):
assert self.series_service.get_qcl_by_id(10) == None
qcl = test_util.add_qcl(self.session)
db_qcl = self.series_service.get_qcl_by_id(qcl.id)
assert qcl.code == db_qcl.code
def test_get_all_qcls(self):
assert self.series_service.get_all_qcls() == []
qcl = test_util.add_qcl(self.session)
all_qcls = self.series_service.get_all_qcls()
assert len(all_qcls) == 1
assert qcl.id == all_qcls[0].id
def test_get_all_methods(self):
assert self.series_service.get_all_methods() == []
method = test_util.add_method(self.session)
all_methods = self.series_service.get_all_methods()
assert len(all_methods) == 1
assert method.id == all_methods[0].id
def test_get_method_by_id(self):
assert self.series_service.get_method_by_id(10) == None
method = test_util.add_method(self.session)
db_method = self.series_service.get_method_by_id(method.id)
assert method.description == db_method.description
def test_delete_dvs(self):
series = test_util.add_series(self.session)
dvs = series.data_values
subset = dvs[:5]
self.series_service.delete_dvs([x.local_date_time for x in subset])
assert self.series_service.get_data_value_by_id(subset[0].id) == None
series = self.series_service.get_series_by_id(series.id) # Reload
assert len(series.data_values) == 5
def test_update_dvs(self):
series = test_util.add_series(self.session)
dvs = series.data_values
subset = dvs[:5]
for i in range(len(subset)):
subset[i].data_value = 100
self.series_service.update_dvs(subset)
series = self.series_service.get_series_by_id(series.id)
assert series.data_values[0].data_value == 100
def test_create_new_series(self):
site = test_util.add_site(self.session)
variable = test_util.add_variable(self.session)
method = test_util.add_method(self.session)
source = test_util.add_source(self.session)
qcl = test_util.add_qcl(self.session)
dvs = []
for val in range(10):
dv = DataValue()
dv.data_value = val
dv.site_id = site.id
dv.variable_id = variable.id
dv.method_id = method.id
dv.source_id = source.id
dv.quality_control_level_id = qcl.id
dvs.append(dv)
series = self.series_service.create_new_series(dvs, site.id, variable.id, method.id, source.id, qcl.id)
assert series != None
assert len(series.data_values) == 10
assert series.site_id == site.id
assert series.variable_id == variable.id
def test_update_series(self):
series = test_util.add_series(self.session)
series.site_code = "NEW"
series.variable_code = "NEW"
self.series_service.update_series(series)
series = self.series_service.get_series_by_id(series.id)
assert series.site_code == "NEW"
assert series.variable_code == "NEW"
def test_create_method(self):
description = "This tests creating a method"
link = "http://www.example.com"
method = self.series_service.create_method(description, link)
assert method.id != None
assert method.description == description
assert method.link == link
def test_create_variable(self):
unit = test_util.add_unit(self.session)
variable = self.series_service.create_variable("Code", "Name", "Speciation", unit.id, "SampleMedium",
"ValueType", True, # is_regular
5.0, # time_support
unit.id, # time_unit_id
"DataType", "GeneralCategory", -999.0) # no_data_value
assert variable.id != None
assert variable.code == "Code"
assert variable.variable_unit_id == unit.id
def test_create_qcl(self):
qcl = self.series_service.create_qcl("Code", "Definition", "Explanation")
assert qcl.id != None
assert qcl.code == "Code"
def test_delete_series(self):
series = test_util.add_series(self.session)
assert self.series_service.get_series_by_id(series.id) != None
self.series_service.delete_series(series)
assert self.series_service.get_series_by_id(series.id) == None
def test_delete_values(self):
series = test_util.add_series(self.session)
assert self.series_service.get_series_by_id(series.id) != None
self.series_service.delete_values_by_series(series)
val = self.series_service.get_series_by_id(series.id)
print val
assert val != None
def test_qcl_exists(self):
qcl = test_util.add_qcl(self.session)
assert self.series_service.qcl_exists(qcl) == True
qcl.code = "00000"
qcl.definition = "A new definition"
assert self.series_service.qcl_exists(qcl) == False
def test_method_exists(self):
method = test_util.add_method(self.session)
assert self.series_service.method_exists(method) == True
method.description = "A new description"
assert self.series_service.method_exists(method) == False
def test_variable_exists(self):
variable = test_util.add_variable(self.session)
assert self.series_service.variable_exists(variable)
variable.code = "00000"
variable.name = "A new name"
assert not self.series_service.variable_exists(variable)
class TestSeriesService:
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(self.connection_string, debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
def test_get_db_version(self):
version = test_util.add_version(self.session)
db_version = self.series_service.get_db_version()
assert version.version_number == db_version
def test_get_all_sites_empty(self):
sites = self.series_service.get_used_sites()
#assert len(sites) == 0
assert sites is None
def test_create_qualifier(self):
qual = Qualifier()
qual.code = "ABC123"
qual.description = "This is a test"
self.series_service.create_qualifier_by_qual(qual)
assert qual.id is not None
def test_get_qualifiers(self):
assert self.series_service.get_all_qualifiers() == []
qual= self.series_service.create_qualifier("ABC123","This is a test")
db_qual = self.series_service.get_all_qualifiers()[0]
assert qual.id == db_qual.id
def test_get_all_sites(self):
assert self.series_service.get_used_sites() is None
site = test_util.add_site(self.session)
sites = self.series_service.get_used_sites()
assert sites is None
if isinstance(sites, list) and len(sites) > 0:
assert site.code == sites[0].code
series = test_util.add_series(self.session)
site = series.site
sites = self.series_service.get_used_sites()
assert len(sites) == 1
if isinstance(sites, list) and len(sites) > 0:
assert site.code == sites[0].code
def test_get_site_by_id_fail(self):
assert self.series_service.get_site_by_id(0) == None
site = test_util.add_site(self.session)
db_site = self.series_service.get_site_by_id(10)
assert db_site == None
def test_get_site_by_id(self):
site = test_util.add_site(self.session)
db_site = self.series_service.get_site_by_id(site.id)
assert db_site != None
assert site.code == db_site.code
def test_get_all_variables(self):
assert self.series_service.get_all_variables() == []
variable = test_util.add_variable(self.session)
variables = self.series_service.get_all_variables()
assert len(variables) == 1
assert variable.code == variables[0].code
def test_get_variable_by_id(self):
assert self.series_service.get_variable_by_id(10) == None
variable = test_util.add_variable(self.session)
db_var = self.series_service.get_variable_by_id(variable.id)
assert db_var != None
assert db_var.code == variable.code
def test_get_variables_by_site_code(self):
assert self.series_service.get_variables_by_site_code('ABC123') == []
series = test_util.add_series(self.session)
variable = series.variable
db_variables = self.series_service.get_variables_by_site_code(series.site_code)
assert db_variables != None
assert variable.code == db_variables[0].code
def test_get_all_units(self):
assert self.series_service.get_all_units() == []
unit = test_util.add_unit(self.session)
units = self.series_service.get_all_units()
assert len(units) == 1
assert unit.name == units[0].name
def test_get_unit_by_name(self):
assert self.series_service.get_unit_by_name("FAIL") == None
unit = test_util.add_unit(self.session)
db_unit = self.series_service.get_unit_by_name(unit.name)
assert unit.id == db_unit.id
def test_get_unit_by_id(self):
assert self.series_service.get_unit_by_id(10) == None
unit = test_util.add_unit(self.session)
db_unit = self.series_service.get_unit_by_id(unit.id)
assert unit.name == db_unit.name
def test_get_all_series(self):
assert self.series_service.get_all_series() == []
series = test_util.add_series(self.session)
all_series = self.series_service.get_all_series()
assert all_series != []
assert series.id == all_series[0].id
def test_get_series_by_id(self):
assert self.series_service.get_series_by_id(10) == None
series = test_util.add_series(self.session)
db_series = self.series_service.get_series_by_id(series.id)
assert series.id == db_series.id
def test_get_series_by_id_quint(self):
assert self.series_service.get_series_by_id_quint(10, 10, 10, 10, 10) == None
series = test_util.add_series(self.session)
db_series = self.series_service.get_series_by_id_quint(series.site_id, series.variable_id, series.method_id,
series.source_id, series.quality_control_level_id)
assert series.id == db_series.id
def test_series_exists(self):
assert self.series_service.series_exists_quint(10, 10, 10, 10, 10) == False
series = test_util.add_series(self.session)
site_id = series.site_id
var_id = series.variable_id
method_id = series.method_id
source_id = series.source_id
qcl_id = series.quality_control_level_id
assert self.series_service.series_exists_quint(site_id, var_id, method_id, source_id, qcl_id) == True
## TODO Unittest save_series, save_as, save_as_existing
'''
def test_save_series(self):
series = Series()
site = test_util.add_site(self.session)
variable = test_util.add_variable(self.session)
method = test_util.add_method(self.session)
source = test_util.add_source(self.session)
qcl = test_util.add_qcl(self.session)
series.site_id = site.id
series.variable_id = variable.id
series.method_id = method.id
series.source_id = source.id
series.quality_control_level_id = qcl.id
dvs = []
for val in range(10):
dv = DataValue()
dv.data_value = val
dv.site_id = site.id
dv.variable_id = variable.id
dv.method_id = method.id
dv.source_id = source.id
dv.quality_control_level_id = qcl.id
dvs.append(dv)
print series.variable_code
assert self.series_service.save_series(series)
assert self.series_service.series_exists(site.id, variable.id, method.id, source.id, qcl.id)
assert not self.series_service.save_series(series)
'''
def test_get_data_value_by_id(self):
assert self.series_service.get_data_value_by_id(10) == None
data_values = test_util.add_series(self.session).data_values
dv = data_values[0]
db_dv = self.series_service.get_data_value_by_id(dv.id)
assert dv.data_value == db_dv.data_value
def test_get_qcl_by_id(self):
assert self.series_service.get_qcl_by_id(10) == None
qcl = test_util.add_qcl(self.session)
db_qcl = self.series_service.get_qcl_by_id(qcl.id)
assert qcl.code == db_qcl.code
def test_get_all_qcls(self):
assert self.series_service.get_all_qcls() == []
qcl = test_util.add_qcl(self.session)
all_qcls = self.series_service.get_all_qcls()
assert len(all_qcls) == 1
assert qcl.id == all_qcls[0].id
def test_get_all_methods(self):
assert self.series_service.get_all_methods() == []
method = test_util.add_method(self.session)
all_methods = self.series_service.get_all_methods()
assert len(all_methods) == 1
assert method.id == all_methods[0].id
def test_get_method_by_id(self):
assert self.series_service.get_method_by_id(10) == None
method = test_util.add_method(self.session)
db_method = self.series_service.get_method_by_id(method.id)
assert method.description == db_method.description
def test_delete_dvs(self):
series = test_util.add_series(self.session)
dvs = series.data_values
subset = dvs[:5]
self.series_service.delete_dvs([x.id for x in subset])
assert self.series_service.get_data_value_by_id(subset[0].id) == None
series = self.series_service.get_series_by_id(series.id) # Reload
assert len(series.data_values) == 5
def test_update_dvs(self):
series = test_util.add_series(self.session)
dvs = series.data_values
subset = dvs[:5]
for i in range(len(subset)):
subset[i].data_value = 100
self.series_service.update_dvs(subset)
series = self.series_service.get_series_by_id(series.id)
assert series.data_values[0].data_value == 100
def test_create_new_series(self):
site = test_util.add_site(self.session)
variable = test_util.add_variable(self.session)
method = test_util.add_method(self.session)
source = test_util.add_source(self.session)
qcl = test_util.add_qcl(self.session)
dvs = []
for val in range(10):
dv = DataValue()
dv.data_value = val
dv.site_id = site.id
dv.variable_id = variable.id
dv.method_id = method.id
dv.source_id = source.id
dv.quality_control_level_id = qcl.id
dvs.append(dv)
series = self.series_service.create_new_series(dvs, site.id, variable.id, method.id, source.id, qcl.id)
assert series != None
assert len(series.data_values) == 10
assert series.site_id == site.id
assert series.variable_id == variable.id
def test_update_series(self):
series = test_util.add_series(self.session)
series.site_code = "NEW"
series.variable_code = "NEW"
self.series_service.update_series(series)
series = self.series_service.get_series_by_id(series.id)
assert series.site_code == "NEW"
assert series.variable_code == "NEW"
def test_create_method(self):
description = "This tests creating a method"
link = "http://www.example.com"
method = self.series_service.create_method(description, link)
assert method.id != None
assert method.description == description
assert method.link == link
def test_create_variable(self):
unit = test_util.add_unit(self.session)
variable = self.series_service.create_variable("Code", "Name", "Speciation", unit.id, "SampleMedium",
"ValueType", True, # is_regular
5.0, # time_support
unit.id, # time_unit_id
"DataType", "GeneralCategory", -999.0) # no_data_value
assert variable.id != None
assert variable.code == "Code"
assert variable.variable_unit_id == unit.id
def test_create_qcl(self):
qcl = self.series_service.create_qcl("Code", "Definition", "Explanation")
assert qcl.id != None
assert qcl.code == "Code"
def test_delete_series(self):
series = test_util.add_series(self.session)
assert self.series_service.get_series_by_id(series.id) != None
self.series_service.delete_series(series)
assert self.series_service.get_series_by_id(series.id) == None
def test_qcl_exists(self):
qcl = test_util.add_qcl(self.session)
assert self.series_service.qcl_exists(qcl) == True
qcl.code = "00000"
qcl.definition = "A new definition"
assert self.series_service.qcl_exists(qcl) == False
def test_method_exists(self):
method = test_util.add_method(self.session)
assert self.series_service.method_exists(method) == True
method.description = "A new description"
assert self.series_service.method_exists(method) == False
def test_variable_exists(self):
variable = test_util.add_variable(self.session)
assert self.series_service.variable_exists(variable)
variable.code = "00000"
variable.name = "A new name"
assert not self.series_service.variable_exists(variable)
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(self.connection_string, debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
class TestSeriesService:
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(connection_string=self.connection_string, debug=False)
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
self.memory_database = MemoryDatabase()
self.memory_database.set_series_service(self.series_service)
self.session = self.memory_database.series_service._session_factory.get_session()
self.series = test_util.add_series_bulk_data(self.session)
#assert len(self.series.data_values) == 100
self.edit_service =EditService(1, connection= self.memory_database)
"""
@pytest.fixture(scope="class", autouse=True)
def build_db(self):
"""
#Builds an empty sqlite (in-memory) database for testing
#:return: None
"""
# path to the ddl script for building the database
ddlpath= abspath(join(dirname(__file__), 'data/empty.sql'))
# create and empty sqlite database for testing
db = dbconnection.createConnection('sqlite', ':memory:')
# read the ddl script and remove the first (BEGIN TRANSACTION) and last (COMMIT) lines
ddl = open(ddlpath, 'r').read()
ddl = ddl.replace('BEGIN TRANSACTION;','')
ddl = ddl.replace('COMMIT;','')
# execute each statement to build the odm2 database
for line in ddl.split(');')[:-1]:
try:
db.engine.execute(line + ');')
except Exception as e:
print e
self.write = CreateODM2(db)
self.engine= db.engine
globals['write'] = self.write
globals['engine'] = self.engine
globals['db'] = db
# return self.write, self.engine
def setup(self):
self.writer = globals['write']
self.engine = globals['engine']
self.db = globals['db']
"""
def test_duplicate_values_filter(self):
duplicate_value = self.memory_database.getDataValues()[0]
self.memory_database.addPoints(duplicate_value)
vals = self.edit_service.duplicate_value_filter()
assert len(vals) == 1
def test_save_series(self):
stlen = len(self.series.data_values)
assert self.edit_service.save()
val = self.series_service.get_series_by_id(self.series.id)
assert len(val.data_values)==stlen
def test_save_as_series(self):
var = test_util.add_variable(self.session)
print var
stlen = len(self.series.data_values)
assert self.edit_service.save_as(var= var)
assert self.edit_service.memDB.series_service.series_exists_quint(self.series.site_id, var.id, self.series.method_id, self.series.source_id, self.series.quality_control_level_id)
def test_save_as_existing_series(self):
var = test_util.add_variable(self.session)
assert self.edit_service.save_existing(var = var)
def test_save_append_keep(self):
#TODO add custon test
len1= len(self.series.data_values)
# keep data from original series if overlap:
svalue = self.series.data_values[0]
self.edit_service.memDB.updateValue([svalue.local_date_time],'+', 5 )
news= self.edit_service.memDB.series_service.get_series_by_id(self.series.id)
result = self.edit_service.save_appending(overwrite = False)
len2= len(self.series.data_values)
assert len1 == len2
assert news.data_values[0].data_value == svalue.data_value
assert result
def test_save_append_overwrite(self):
len1= len(self.series.data_values)
svalue = self.series.data_values[0]
self.edit_service.memDB.updateValue([svalue.local_date_time],'+', 5)
news= self.edit_service.memDB.series_service.get_series_by_id(self.series.id)
result = self.edit_service.save_appending(overwrite = True)
len2= len(self.series.data_values)
assert len1 == len2
assert news.data_values[0].data_value == svalue.data_value + 5
assert result
class TestSeriesService:
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(
connection_string=self.connection_string, debug=False)
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
self.memory_database = MemoryDatabase()
self.memory_database.set_series_service(self.series_service)
self.session = self.memory_database.series_service._session_factory.get_session(
)
self.series = test_util.add_series_bulk_data(self.session)
#assert len(self.series.data_values) == 100
self.edit_service = EditService(1, connection=self.memory_database)
"""
@pytest.fixture(scope="class", autouse=True)
def build_db(self):
"""
#Builds an empty sqlite (in-memory) database for testing
#:return: None
"""
# path to the ddl script for building the database
ddlpath= abspath(join(dirname(__file__), 'data/empty.sql'))
# create and empty sqlite database for testing
db = dbconnection.createConnection('sqlite', ':memory:')
# read the ddl script and remove the first (BEGIN TRANSACTION) and last (COMMIT) lines
ddl = open(ddlpath, 'r').read()
ddl = ddl.replace('BEGIN TRANSACTION;','')
ddl = ddl.replace('COMMIT;','')
# execute each statement to build the odm2 database
for line in ddl.split(');')[:-1]:
try:
db.engine.execute(line + ');')
except Exception as e:
print e
self.write = CreateODM2(db)
self.engine= db.engine
globals['write'] = self.write
globals['engine'] = self.engine
globals['db'] = db
# return self.write, self.engine
def setup(self):
self.writer = globals['write']
self.engine = globals['engine']
self.db = globals['db']
"""
def test_duplicate_values_filter(self):
duplicate_value = self.memory_database.getDataValues()[0]
self.memory_database.addPoints(duplicate_value)
vals = self.edit_service.duplicate_value_filter()
assert len(vals) == 1
def test_save_series(self):
stlen = len(self.series.data_values)
assert self.edit_service.save()
val = self.series_service.get_series_by_id(self.series.id)
assert len(val.data_values) == stlen
def test_save_as_series(self):
var = test_util.add_variable(self.session)
print var
stlen = len(self.series.data_values)
assert self.edit_service.save_as(var=var)
assert self.edit_service.memDB.series_service.series_exists_quint(
self.series.site_id, var.id, self.series.method_id,
self.series.source_id, self.series.quality_control_level_id)
def test_save_as_existing_series(self):
var = test_util.add_variable(self.session)
assert self.edit_service.save_existing(var=var)
def test_save_append_keep(self):
#TODO add custon test
len1 = len(self.series.data_values)
# keep data from original series if overlap:
svalue = self.series.data_values[0]
self.edit_service.memDB.updateValue([svalue.local_date_time], '+', 5)
news = self.edit_service.memDB.series_service.get_series_by_id(
self.series.id)
result = self.edit_service.save_appending(overwrite=False)
len2 = len(self.series.data_values)
assert len1 == len2
assert news.data_values[0].data_value == svalue.data_value
assert result
def test_save_append_overwrite(self):
len1 = len(self.series.data_values)
svalue = self.series.data_values[0]
self.edit_service.memDB.updateValue([svalue.local_date_time], '+', 5)
news = self.edit_service.memDB.series_service.get_series_by_id(
self.series.id)
result = self.edit_service.save_appending(overwrite=True)
len2 = len(self.series.data_values)
assert len1 == len2
assert news.data_values[0].data_value == svalue.data_value + 5
assert result
class MemoryDatabase(object):
### this code should be changed to work with the database abstract layer so that sql queries are not in the code
# series_service is a SeriesService
def __init__(self, taskserver=None):
self.editLoaded = False
self.df = None
# Series_Service handles remote database
self.series_service = None
# Memory_service handles in memory database
self.mem_service = SeriesService("sqlite:///:memory:")
# TODO clean up closing of program
# if taskserver is None:
#numproc = cpu_count()
#self.taskserver = TaskServerMP(numproc=numproc)
#else:
self.taskserver = taskserver
def reset_edit(self):
self.mem_service = SeriesService("sqlite:///:memory:")
def set_series_service(self, service):
self.series_service = service
##############
# DB Queries
##############
def getDataValuesDF(self):
logging.debug("update in memory dataframe")
'''
if self.taskserver:
results = self.taskserver.getCompletedTasks()
df=results['UpdateEditDF']
#else:
# self.updateDF()
'''
self.updateDF()
# pick up thread here before it is needed
logging.debug("done updating memory dataframe")
return self.df
def getDataValues(self):
return self.mem_service.get_all_values()
def getEditRowCount(self):
return len(self.df)
def getEditColumns(self):
columns = []
tmp_columns = self.df.columns.tolist()
tmp_columns.remove('DataValue')
tmp_columns.remove('LocalDateTime')
tmp_columns.remove('QualifierID')
columns.append('DataValue')
columns.append('LocalDateTime')
columns.append('QualifierID')
columns.extend(tmp_columns)
return [(x, i) for (i, x) in enumerate(columns)]
# return [(x, i) for (i, x) in enumerate(self.df.columns)]
def getDataValuesforGraph(self, seriesID, noDataValue, startDate=None, endDate=None):
return self.series_service.get_plot_values(seriesID, noDataValue, startDate, endDate)
def getEditDataValuesforGraph(self):
return self.mem_service.get_all_plot_values()
def commit(self):
self.mem_service._edit_session.commit()
def rollback(self):
self.mem_service._edit_session.rollback()
# self.mem_service._session_factory.engine.connect().connection.rollback()
#self.updateDF()
def update(self, updates):
'''
updates : list of dictionary that contains 2 items, id and value
'''
stmt = (DataValue.__table__.update().
where(DataValue.local_date_time == bindparam('id')).
values(DataValue=bindparam('value'))
)
self.mem_service._edit_session.execute(stmt, updates)
# self.updateDF()
def updateValue(self, ids, operator, value):
# query = DataValue.data_value+value
if operator == '+':
query = DataValue.data_value + value
elif operator == '-':
query = DataValue.data_value - value
elif operator == '*':
query = DataValue.data_value * value
elif operator == '=':
query = value
#break into chunks to get around sqlites restriction. allowing user to send in only 999 arguments at once
chunks=self.chunking(ids)
for c in chunks:
q=self.mem_service._edit_session.query(DataValue).filter(DataValue.local_date_time.in_(c))
q.update({DataValue.data_value: query}, False)
#self.updateDF()
def chunking(self, data):
return [data[x:x+998] for x in xrange(0, len(data), 998)]
#break into chunks to get around sqlite's restriction. allowing user to send in only 999 arguments at once
def updateFlag(self, ids, value):
chunks=self.chunking(ids)
for c in chunks:
self.mem_service._edit_session.query(DataValue).filter(DataValue.local_date_time.in_(c))\
.update({DataValue.qualifier_id: value}, False)
def delete(self, ids):
chunks=self.chunking(ids)
for c in chunks:
self.mem_service.delete_dvs(c)
#self.updateDF()
def addPoints(self, points):
"""
Takes in a list of points and loads each point into the database
"""
stmt = DataValue.__table__.insert()
if not isinstance(points, list):
points = [points]
for point in points:
vals = {"DataValue": point[0], "ValueAccuracy": point[1],
"LocalDateTime": point[2], "UTCOffset": point[3],
"DateTimeUTC": point[4], "OffsetValue": point[5],
"OffsetTypeID": point[6], "CensorCode": point[7],
"QualifierID": point[8], "SampleID": point[9],
"SiteID": point[10], "VariableID": point[11],
"MethodID": point[12], "SourceID": point[13],
"QualityControlLevelID": point[14]}
self.mem_service._edit_session.execute(stmt, vals)
def stopEdit(self):
self.editLoaded = False
self.df = None
def setConnection(self, service):
self.mem_service = service
# TODO multiprocess this function
def updateDF(self):
'''
if self.taskserver:
# Give tasks to the taskserver to run parallelly
logger.debug("Sending tasks to taskserver")
self.taskserver.setTasks(("UpdateEditDF", self.mem_service))
self.taskserver.processTasks()
else:
'''
self.df = self.mem_service.get_all_values_df()
def initEditValues(self, seriesID):
"""
:param df: dataframe
:return: nothing
"""
if not self.editLoaded:
logger.debug("Load series from db")
self.df = self.series_service.get_values_by_series(seriesID)
self.editLoaded = True
'''
if self.taskserver:
self.taskserver.setTasks([("InitEditValues", (self.mem_service._session_factory.engine, self.df))])
self.taskserver.processTasks()
# results = self.taskserver.getCompletedTasks()
# self.conn = results["InitEditValues"]
else:
''' #TODO: Thread this call
if len(self.df)>0:
self.df.to_sql(name="DataValues", if_exists='replace', con=self.mem_service._session_factory.engine,
index=False)#,flavor='sqlite', chunksize=10000)
logger.debug("done loading database")
else:
logger.debug("no data in series")
def changeSeriesIDs(self, var=None, qcl=None, method=None):
"""
:param var:
:param qcl:
:param method:
:return:
"""
query = self.mem_service._edit_session.query(DataValue)
if var is not None:
logger.debug(var)
query.update({DataValue.variable_id: var})
if method is not None:
logger.debug(method)
query.update({DataValue.method_id: method})
# check that the code is not zero
# if qcl is not None and qcl.code != 0:
if qcl is not None:
logger.debug(qcl)
query.update({DataValue.quality_control_level_id: qcl})
class TestSeriesService:
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.series_service = SeriesService(self.connection_string,
debug=False)
self.session = self.series_service._session_factory.get_session()
engine = self.series_service._session_factory.engine
test_util.build_db(engine)
"""
@pytest.fixture(scope="class", autouse=True)
def build_db(self):
"""
#Builds an empty sqlite (in-memory) database for testing
#:return: None
"""
# path to the ddl script for building the database
ddlpath= abspath(join(dirname(__file__), 'data/empty.sql'))
# create and empty sqlite database for testing
db = dbconnection.createConnection('sqlite', ':memory:')
# read the ddl script and remove the first (BEGIN TRANSACTION) and last (COMMIT) lines
ddl = open(ddlpath, 'r').read()
ddl = ddl.replace('BEGIN TRANSACTION;','')
ddl = ddl.replace('COMMIT;','')
# execute each statement to build the odm2 database
for line in ddl.split(');')[:-1]:
try:
db.engine.execute(line + ');')
except Exception as e:
print e
self.write = CreateODM2(db)
self.engine= db.engine
globals['write'] = self.write
globals['engine'] = self.engine
globals['db'] = db
# return self.write, self.engine
def setup(self):
self.writer = globals['write']
self.engine = globals['engine']
self.db = globals['db']
"""
def test_get_db_version(self):
version = test_util.add_version(self.session)
db_version = self.series_service.get_db_version()
assert version.version_number == db_version
def test_get_all_sites_empty(self):
sites = self.series_service.get_used_sites()
#assert len(sites) == 0
assert sites is None
def test_create_qualifier(self):
qual = Qualifier()
qual.code = "ABC123"
qual.description = "This is a test"
self.series_service.create_qualifier_by_qual(qual)
assert qual.id is not None
def test_get_qualifier_by_code(self):
assert self.series_service.get_all_qualifiers() == []
qual = self.series_service.create_qualifier("ABC123", "This is a test")
db_qual = self.series_service.get_qualifier_by_code("ABC123")
assert qual.id == db_qual.id
def test_get_qualifiers(self):
assert self.series_service.get_all_qualifiers() == []
qual = self.series_service.create_qualifier("ABC123", "This is a test")
db_qual = self.series_service.get_all_qualifiers()[0]
assert qual.id == db_qual.id
def test_get_all_sites(self):
assert self.series_service.get_used_sites() is None
site = test_util.add_site(self.session)
sites = self.series_service.get_used_sites()
assert sites is None
if isinstance(sites, list) and len(sites) > 0:
assert site.code == sites[0].code
series = test_util.add_series(self.session)
site = series.site
sites = self.series_service.get_used_sites()
assert len(sites) == 1
if isinstance(sites, list) and len(sites) > 0:
assert site.code == sites[0].code
def test_get_site_by_id_fail(self):
assert self.series_service.get_site_by_id(0) == None
site = test_util.add_site(self.session)
db_site = self.series_service.get_site_by_id(10)
assert db_site == None
def test_get_site_by_id(self):
site = test_util.add_site(self.session)
db_site = self.series_service.get_site_by_id(site.id)
assert db_site != None
assert site.code == db_site.code
def test_get_all_variables(self):
assert self.series_service.get_all_variables() == []
variable = test_util.add_variable(self.session)
variables = self.series_service.get_all_variables()
assert len(variables) == 1
assert variable.code == variables[0].code
def test_get_variable_by_id(self):
assert self.series_service.get_variable_by_id(10) == None
variable = test_util.add_variable(self.session)
db_var = self.series_service.get_variable_by_id(variable.id)
assert db_var != None
assert db_var.code == variable.code
def test_get_variables_by_site_code(self):
assert self.series_service.get_variables_by_site_code('ABC123') == []
series = test_util.add_series(self.session)
variable = series.variable
db_variables = self.series_service.get_variables_by_site_code(
series.site_code)
assert db_variables != None
assert variable.code == db_variables[0].code
def test_get_all_units(self):
assert self.series_service.get_all_units() == []
unit = test_util.add_unit(self.session)
units = self.series_service.get_all_units()
assert len(units) == 1
assert unit.name == units[0].name
def test_get_unit_by_name(self):
assert self.series_service.get_unit_by_name("FAIL") == None
unit = test_util.add_unit(self.session)
db_unit = self.series_service.get_unit_by_name(unit.name)
assert unit.id == db_unit.id
def test_get_unit_by_id(self):
assert self.series_service.get_unit_by_id(10) == None
unit = test_util.add_unit(self.session)
db_unit = self.series_service.get_unit_by_id(unit.id)
assert unit.name == db_unit.name
def test_get_all_series(self):
assert self.series_service.get_all_series() == []
series = test_util.add_series(self.session)
all_series = self.series_service.get_all_series()
assert all_series != []
assert series.id == all_series[0].id
def test_get_series_by_id(self):
assert self.series_service.get_series_by_id(10) == None
series = test_util.add_series(self.session)
db_series = self.series_service.get_series_by_id(series.id)
assert series.id == db_series.id
def test_get_series_by_id_quint(self):
assert self.series_service.get_series_by_id_quint(10, 10, 10, 10,
10) == None
series = test_util.add_series(self.session)
db_series = self.series_service.get_series_by_id_quint(
series.site_id, series.variable_id, series.method_id,
series.source_id, series.quality_control_level_id)
assert series.id == db_series.id
def test_series_exists(self):
assert self.series_service.series_exists_quint(10, 10, 10, 10,
10) == False
series = test_util.add_series(self.session)
site_id = series.site_id
var_id = series.variable_id
method_id = series.method_id
source_id = series.source_id
qcl_id = series.quality_control_level_id
assert self.series_service.series_exists_quint(site_id, var_id,
method_id, source_id,
qcl_id) == True
'''
def test_save_series(self):
series = Series()
site = test_util.add_site(self.session)
variable = test_util.add_variable(self.session)
method = test_util.add_method(self.session)
source = test_util.add_source(self.session)
qcl = test_util.add_qcl(self.session)
series.site_id = site.id
series.variable_id = variable.id
series.method_id = method.id
series.source_id = source.id
series.quality_control_level_id = qcl.id
dvs = []
for val in range(10):
dv = DataValue()
dv.data_value = val
dv.site_id = site.id
dv.variable_id = variable.id
dv.method_id = method.id
dv.source_id = source.id
dv.quality_control_level_id = qcl.id
dvs.append(dv)
print series.variable_code
assert self.series_service.save_series(series)
assert self.series_service.series_exists(site.id, variable.id, method.id, source.id, qcl.id)
assert not self.series_service.save_series(series)
'''
def test_get_data_value_by_id(self):
assert self.series_service.get_data_value_by_id(10) == None
data_values = test_util.add_series(self.session).data_values
dv = data_values[0]
db_dv = self.series_service.get_data_value_by_id(dv.id)
assert dv.data_value == db_dv.data_value
def test_get_qcl_by_id(self):
assert self.series_service.get_qcl_by_id(10) == None
qcl = test_util.add_qcl(self.session)
db_qcl = self.series_service.get_qcl_by_id(qcl.id)
assert qcl.code == db_qcl.code
def test_get_all_qcls(self):
assert self.series_service.get_all_qcls() == []
qcl = test_util.add_qcl(self.session)
all_qcls = self.series_service.get_all_qcls()
assert len(all_qcls) == 1
assert qcl.id == all_qcls[0].id
def test_get_all_methods(self):
assert self.series_service.get_all_methods() == []
method = test_util.add_method(self.session)
all_methods = self.series_service.get_all_methods()
assert len(all_methods) == 1
assert method.id == all_methods[0].id
def test_get_method_by_id(self):
assert self.series_service.get_method_by_id(10) == None
method = test_util.add_method(self.session)
db_method = self.series_service.get_method_by_id(method.id)
assert method.description == db_method.description
def test_delete_dvs(self):
series = test_util.add_series(self.session)
dvs = series.data_values
subset = dvs[:5]
self.series_service.delete_dvs([x.local_date_time for x in subset])
assert self.series_service.get_data_value_by_id(subset[0].id) == None
series = self.series_service.get_series_by_id(series.id) # Reload
assert len(series.data_values) == 5
def test_update_dvs(self):
series = test_util.add_series(self.session)
dvs = series.data_values
subset = dvs[:5]
for i in range(len(subset)):
subset[i].data_value = 100
self.series_service.update_dvs(subset)
series = self.series_service.get_series_by_id(series.id)
assert series.data_values[0].data_value == 100
def test_create_new_series(self):
site = test_util.add_site(self.session)
variable = test_util.add_variable(self.session)
method = test_util.add_method(self.session)
source = test_util.add_source(self.session)
qcl = test_util.add_qcl(self.session)
dvs = []
for val in range(10):
dv = DataValue()
dv.data_value = val
dv.site_id = site.id
dv.variable_id = variable.id
dv.method_id = method.id
dv.source_id = source.id
dv.quality_control_level_id = qcl.id
dvs.append(dv)
series = self.series_service.create_new_series(dvs, site.id,
variable.id, method.id,
source.id, qcl.id)
assert series != None
assert len(series.data_values) == 10
assert series.site_id == site.id
assert series.variable_id == variable.id
def test_update_series(self):
series = test_util.add_series(self.session)
series.site_code = "NEW"
series.variable_code = "NEW"
self.series_service.update_series(series)
series = self.series_service.get_series_by_id(series.id)
assert series.site_code == "NEW"
assert series.variable_code == "NEW"
def test_create_method(self):
description = "This tests creating a method"
link = "http://www.example.com"
method = self.series_service.create_method(description, link)
assert method.id != None
assert method.description == description
assert method.link == link
def test_create_variable(self):
unit = test_util.add_unit(self.session)
variable = self.series_service.create_variable(
"Code",
"Name",
"Speciation",
unit.id,
"SampleMedium",
"ValueType",
True, # is_regular
5.0, # time_support
unit.id, # time_unit_id
"DataType",
"GeneralCategory",
-999.0) # no_data_value
assert variable.id != None
assert variable.code == "Code"
assert variable.variable_unit_id == unit.id
def test_create_qcl(self):
qcl = self.series_service.create_qcl("Code", "Definition",
"Explanation")
assert qcl.id != None
assert qcl.code == "Code"
def test_delete_series(self):
series = test_util.add_series(self.session)
assert self.series_service.get_series_by_id(series.id) != None
self.series_service.delete_series(series)
assert self.series_service.get_series_by_id(series.id) == None
def test_delete_values(self):
series = test_util.add_series(self.session)
assert self.series_service.get_series_by_id(series.id) != None
self.series_service.delete_values_by_series(series)
val = self.series_service.get_series_by_id(series.id)
print val
assert val != None
def test_qcl_exists(self):
qcl = test_util.add_qcl(self.session)
assert self.series_service.qcl_exists(qcl) == True
qcl.code = "00000"
qcl.definition = "A new definition"
assert self.series_service.qcl_exists(qcl) == False
def test_method_exists(self):
method = test_util.add_method(self.session)
assert self.series_service.method_exists(method) == True
method.description = "A new description"
assert self.series_service.method_exists(method) == False
def test_variable_exists(self):
variable = test_util.add_variable(self.session)
assert self.series_service.variable_exists(variable)
variable.code = "00000"
variable.name = "A new name"
assert not self.series_service.variable_exists(variable)
def reset_edit(self):
self.mem_service = SeriesService("sqlite:///:memory:")
