def setUp(self):
"""
Reset the database before each test.
"""
# self.reset_database()
self.flow_service = FlowService()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(admin=self.test_user)
### Insert some starting data in the database.
categ1 = model.AlgorithmCategory('one', True)
self.categ1 = dao.store_entity(categ1)
categ2 = model.AlgorithmCategory('two', rawinput=True)
self.categ2 = dao.store_entity(categ2)
algo = model.AlgorithmGroup("test_module1", "classname1", categ1.id)
self.algo1 = dao.store_entity(algo)
algo = model.AlgorithmGroup("test_module2", "classname2", categ2.id)
dao.store_entity(algo)
algo = model.AlgorithmGroup("tvb_test.core.services.flowservice_test", "ValidTestAdapter", categ2.id)
adapter = dao.store_entity(algo)
algo = model.Algorithm(adapter.id, 'ident', name='', req_data='', param_name='', output='')
self.algo_inst = dao.store_entity(algo)
algo = model.AlgorithmGroup("test_module3", "classname3", categ1.id)
dao.store_entity(algo)
algo = model.Algorithm(self.algo1.id, 'id', name='', req_data='', param_name='', output='')
self.algo_inst = dao.store_entity(algo)
def _create_algo_for_upload():
""" Creates a fake algorithm for an upload category. """
category = dao.store_entity(
model.AlgorithmCategory("upload_category", rawinput=True))
algo_group = dao.store_entity(
model.AlgorithmGroup("module", "classname", category.id))
return dao.store_entity(model.Algorithm(algo_group.id, "algo"))
def __init_algorithmn(self):
"""
Insert some starting data in the database.
"""
categ1 = model.AlgorithmCategory('one', True)
self.categ1 = dao.store_entity(categ1)
algo = model.AlgorithmGroup(TEST_ADAPTER_VALID_MODULE, TEST_ADAPTER_VALID_CLASS, categ1.id)
adapter = dao.store_entity(algo)
algo = model.Algorithm(adapter.id, 'ident', name='', req_data='', param_name='', output='')
self.algo_inst = dao.store_entity(algo)
def __init_algorithmn(self):
"""
Insert some starting data in the database.
"""
categ1 = model.AlgorithmCategory('one', True)
self.categ1 = dao.store_entity(categ1)
algo = model.AlgorithmGroup("tvb_test.core.services.flowservice_test", "ValidTestAdapter", categ1.id)
adapter = dao.store_entity(algo)
algo = model.Algorithm(adapter.id, 'ident', name='', req_data='', param_name='', output='')
self.algo_inst = dao.store_entity(algo)
def ensure_db(self):
"""
Ensure algorithm exists in DB and add it if not
"""
cat = dao.get_uploader_categories()[0]
cls = self.__class__
cmd, cnm = cls.__module__, cls.__name__
gp = dao.find_group(cmd, cnm)
if gp is None:
gp = model.AlgorithmGroup(cmd, cnm, cat.id)
gp = dao.store_entity(gp)
dao.store_entity(model.Algorithm(gp.id, cnm, cnm))
self.algorithm_group = gp
def setUp(self):
""" Prepare some entities to work with during tests:"""
self.flow_service = FlowService()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(admin=self.test_user)
### Insert some starting data in the database.
categ1 = model.AlgorithmCategory('one', True)
self.categ1 = dao.store_entity(categ1)
categ2 = model.AlgorithmCategory('two', rawinput=True)
self.categ2 = dao.store_entity(categ2)
group1 = model.AlgorithmGroup("test_module1", "classname1", categ1.id)
self.algo_group1 = dao.store_entity(group1)
group2 = model.AlgorithmGroup("test_module2", "classname2", categ2.id)
self.algo_group2 = dao.store_entity(group2)
group3 = model.AlgorithmGroup("test_module3", "classname3", categ1.id)
self.algo_group3 = dao.store_entity(group3)
group_v = model.AlgorithmGroup(TEST_ADAPTER_VALID_MODULE,
TEST_ADAPTER_VALID_CLASS, categ2.id)
self.algo_group_v = dao.store_entity(group_v)
algo_v = model.Algorithm(self.algo_group_v.id,
'ident',
name='',
req_data='',
param_name='',
output='')
self.algorithm_v = dao.store_entity(algo_v)
algo1 = model.Algorithm(self.algo_group1.id,
'id',
name='',
req_data='',
param_name='',
output='')
self.algorithm1 = dao.store_entity(algo1)
def test_get_linkable_projects(self):
"""
Test for retrieving the projects for a given user.
"""
initial_projects = self.project_service.retrieve_projects_for_user(
self.test_user.id)[0]
self.assertEqual(len(initial_projects), 0, "Database was not reseted!")
test_proj = []
user1 = TestFactory.create_user("another_user")
for i in range(4):
test_proj.append(
TestFactory.create_project(self.test_user if i < 3 else user1,
'test_proj' + str(i)))
project_storage = self.structure_helper.get_project_folder(
test_proj[0])
result_meta = {
DataTypeMetaData.KEY_OPERATION_TYPE: "Upload",
DataTypeMetaData.KEY_AUTHOR: "John Doe",
DataTypeMetaData.KEY_SUBJECT: "subj1",
DataTypeMetaData.KEY_STATE: "test_state",
DataTypeMetaData.KEY_NODE_TYPE: "test_data",
DataTypeMetaData.KEY_DATE: "test_date",
DataTypeMetaData.KEY_GID: generate_guid()
}
entity = dao.store_entity(model.AlgorithmCategory("category"))
entity = dao.store_entity(
model.AlgorithmGroup("module", "classname", entity.id))
entity = dao.store_entity(model.Algorithm(entity.id, "algo"))
operation = model.Operation(self.test_user.id, test_proj[0].id,
entity.id, "")
operation = dao.store_entity(operation)
project_storage = os.path.join(project_storage, str(operation.id))
os.makedirs(project_storage)
entity = DataTypeMetaData(result_meta)
datatype = dao.store_entity(
model.DataType(module="test_data",
subject="subj1",
state="test_state",
operation_id=operation.id))
linkable = self.project_service.get_linkable_projects_for_user(
self.test_user.id, str(datatype.id))[0]
self.assertEqual(len(linkable), 2,
"Wrong count of link-able projects!")
proj_names = [project.name for project in linkable]
self.assertTrue(test_proj[1].name in proj_names)
self.assertTrue(test_proj[2].name in proj_names)
self.assertFalse(test_proj[3].name in proj_names)
def __create_instance(self, category_key, class_ref, init_parameter=None):
"""
Validate Class reference.
Return None of Algorithm instance, from class reference.
"""
if self.matlab_executable:
return model.AlgorithmGroup(
class_ref.__module__,
class_ref.__name__,
category_key,
init_parameter=init_parameter,
last_introspection_check=datetime.datetime.now())
else:
if self.__is_matlab_parent(inspect.getclasstree([class_ref])):
self.logger.debug("Skip Adapter because MATLAB is not found:" +
str(class_ref))
return None
else:
return model.AlgorithmGroup(
class_ref.__module__,
class_ref.__name__,
category_key,
init_parameter=init_parameter,
last_introspection_check=datetime.datetime.now())
def __init__(self):
now = datetime.now()
micro_postfix = "_%d" % now.microsecond
# Here create all structures needed later for data types creation
self.files_helper = FilesHelper()
# First create user
user = model.User("datatype_factory_user" + micro_postfix, "test_pass",
"*****@*****.**" + micro_postfix, True, "user")
self.user = dao.store_entity(user)
# Now create a project
project_service = ProjectService()
data = dict(name='DatatypesFactoryProject' + micro_postfix,
description='test_desc',
users=[])
self.project = project_service.store_project(self.user, True, None,
**data)
# Create algorithm
alg_category = model.AlgorithmCategory('one', True)
dao.store_entity(alg_category)
alg_group = model.AlgorithmGroup("test_module1", "classname1",
alg_category.id)
dao.store_entity(alg_group)
algorithm = model.Algorithm(alg_group.id,
'id',
name='',
req_data='',
param_name='',
output='')
self.algorithm = dao.store_entity(algorithm)
#Create an operation
self.meta = {
DataTypeMetaData.KEY_SUBJECT: self.USER_FULL_NAME,
DataTypeMetaData.KEY_STATE: self.DATATYPE_STATE
}
operation = model.Operation(self.user.id,
self.project.id,
self.algorithm.id,
'test parameters',
meta=json.dumps(self.meta),
status="FINISHED",
method_name=ABCAdapter.LAUNCH_METHOD)
self.operation = dao.store_entity(operation)
def __create_instance(self, category_key, class_ref, init_parameter=None):
"""
Validate Class reference.
Return None or Algorithm instance, from class reference.
"""
if class_ref.can_be_active():
return model.AlgorithmGroup(
class_ref.__module__,
class_ref.__name__,
category_key,
init_parameter=init_parameter,
last_introspection_check=datetime.datetime.now())
else:
self.logger.warning(
"Skipped Adapter(probably because MATLAB not found):" +
str(class_ref))
return None
group_inst_from_db = dao.find_group(group.module, group.classname,
group.init_parameter)
adapter = ABCAdapter.build_adapter(group)
has_sub_algorithms = False
ui_name = group.displayname
if isinstance(adapter, ABCGroupAdapter):
group.algorithm_param_name = adapter.get_algorithm_param()
has_sub_algorithms = True
if group_inst_from_db is None:
self.logger.info(
str(group.module) + " will be stored new in DB")
group = model.AlgorithmGroup(
group.module,
group.classname,
category_key,
group.algorithm_param_name,
group.init_parameter,
datetime.datetime.now(),
subsection_name=group.subsection_name,
description=group.description)
else:
self.logger.info(str(group.module) + " will be updated")
group = group_inst_from_db
if hasattr(adapter, "_ui_name"):
ui_name = getattr(adapter, "_ui_name")
elif ui_name is None or len(ui_name) == 0:
ui_name = group.classname
if hasattr(adapter, "_ui_description"):
group.description = getattr(adapter, "_ui_description")
if hasattr(adapter, "_ui_subsection"):
group.subsection_name = getattr(adapter, "_ui_subsection")
