def _store_users_happy_flow(self, n_users, prefix=""): """ Store users in happy flow. In this case the transaction should just be commited properly and changes should be visible in database. :param n_users: number of users to be stored by this method """ for idx in range(n_users): TestFactory.create_user(prefix + 'test_user' + str(idx), 'pass', '*****@*****.**', True, 'test')
def _store_users_raises_exception(self, n_users): """ Store users but at the end raise an exception. In case the exception is not handled up until the transactional decorator, all changes should be rolled back. :param n_users: number of users to be stored by this method """ for idx in range(n_users): TestFactory.create_user('test_user' + str(idx), 'pass', '*****@*****.**', True, 'test') raise Exception("This is just so transactional kicks in and a rollback should be done.")
def _store_users_nested(self, n_users, inner_trans_func): """ This method stores n_users, after which it calls inner_trans_func with n_users as parameter. At the end it raises an exception so transaction will fail. All changes should be reverted regardless if inner_trans_func succeeds or fails. :param n_users: number of users to be stored both by this method and by the passed inner_trans_func :param inner_trans_func: either _store_users_happy_flow or _store_users_raises_exception """ for idx in range(n_users): TestFactory.create_user('test_user_nested' + str(idx), 'pass', '*****@*****.**', True, 'test') inner_trans_func(n_users) raise Exception("This is just so transactional kicks in and a rollback should be done.")
def test_validate_valid(self): """ Pass a valid user and test that it is actually validate. """ self.test_user.role = "ADMINISTRATOR" self.test_user = dao.store_entity(self.test_user) cherrypy.session[common.KEY_USER] = self.test_user TestFactory.create_user(username="******", validated=False) user_before_validation = dao.get_user_by_name("to_validate") self.assertFalse(user_before_validation.validated) self._expect_redirect('/tvb', self.user_c.validate, user_before_validation.username) user_after_validation = dao.get_user_by_id(user_before_validation.id) self.assertTrue(user_after_validation.validated, "User should be validated.") self.assertTrue(cherrypy.session[common.KEY_MESSAGE_TYPE] == common.TYPE_INFO)
def test_retrieve_1project_3usr(self): """ One user as admin, two users as members, getting projects for admin and for any of the members should return one. """ member1 = TestFactory.create_user("member1") member2 = TestFactory.create_user("member2") TestFactory.create_project(self.test_user, 'Testproject', users=[member1.id, member2.id]) projects = self.project_service.retrieve_projects_for_user(self.test_user.id, 1)[0] self.assertEqual(len(projects), 1, "Projects not retrieved properly!") projects = self.project_service.retrieve_projects_for_user(member1.id, 1)[0] self.assertEqual(len(projects), 1, "Projects not retrieved properly!") projects = self.project_service.retrieve_projects_for_user(member2.id, 1)[0] self.assertEqual(len(projects), 1, "Projects not retrieved properly!")
def setUp(self): """ Set up the context needed by the tests. """ self.files_helper = FilesHelper() self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user, self.PROJECT_NAME)
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 reset!") 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]) operation = TestFactory.create_operation(test_user=self.test_user, test_project=test_proj[0]) project_storage = os.path.join(project_storage, str(operation.id)) os.makedirs(project_storage) 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 setUp(self): """ Sets up the environment for running the tests; creates a test user and a test project, saves old configuration and imports a CFF data-set """ self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user) TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project)
def setUp(self): """ Reset the database before each test. """ config.EVENTS_FOLDER = '' self.project_service = ProjectService() self.structure_helper = FilesHelper() self.test_user = TestFactory.create_user()
def setUp(self): """ Reset the database before each test. """ self.clean_database() self.flow_service = FlowService() self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(admin=self.test_user) self.operation = TestFactory.create_operation(test_user=self.test_user, test_project=self.test_project)
def setUp(self): """ Set up any additionally needed parameters. """ self.clean_database() super(GenshiTestNDimensionArray, self).setUp() self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user) self.operation = TestFactory.create_operation(test_user=self.test_user, test_project=self.test_project)
def test_edit_entity_forget_commit(self): """ Commit should be done automatically if you forget for some reason to do so in case of new/update/deletes. """ stored_user = TestFactory.create_user('username', 'password', 'mail', True, 'role') user_id = stored_user.id self._dao_change_user_forget_commit(user_id, 'new_name') edited_user = dao.get_user_by_id(user_id) self.assertEqual(edited_user.username, 'new_name', "User should be edited but it is not. Expected 'new_name' got %s" % edited_user.username)
def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity and a surface; imports a CFF data-set """ self.test_user = TestFactory.create_user("UserRM") self.test_project = TestFactory.import_default_project(self.test_user) self.connectivity = self._get_entity(Connectivity()) self.surface = self._get_entity(CorticalSurface())
def setUp(self): """ Reset the database before each test. """ self.clean_database() initialize_storage() self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user) self.operation_service = OperationService() self.backup_hdd_size = TvbProfile.current.MAX_DISK_SPACE
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) category = dao.get_uploader_categories()[0] self.algorithm = dao.store_entity(model.Algorithm(TEST_ADAPTER_VALID_MODULE, TEST_ADAPTER_VALID_CLASS, category.id))
def test_create_project_happy_flow(self): """ Standard flow for creating a new project. """ user1 = TestFactory.create_user('test_user1') user2 = TestFactory.create_user('test_user2') initial_projects = dao.get_projects_for_user(self.test_user.id) self.assertEqual(len(initial_projects), 0, "Database reset probably failed!") TestFactory.create_project(self.test_user, 'test_project', users=[user1.id, user2.id]) resulting_projects = dao.get_projects_for_user(self.test_user.id) self.assertEqual(len(resulting_projects), 1, "Project with valid data not inserted!") project = resulting_projects[0] if project.name == "test_project": self.assertEqual(project.description, "description", "Description do no match") users_for_project = dao.get_members_of_project(project.id) for user in users_for_project: self.assertTrue(user.id in [user1.id, user2.id], "Users not stored properly.") self.assertTrue(os.path.exists(os.path.join(TvbProfile.current.TVB_STORAGE, FilesHelper.PROJECTS_FOLDER, "test_project")), "Folder for project was not created")
def test_retrieve_3projects_3usr(self): """ Three users, 3 projects. Structure of db: proj1: {admin: user1, members: [user2, user3]} proj2: {admin: user2, members: [user1]} proj3: {admin: user3, members: [user1, user2]} Check valid project returns for all the users. """ member1 = TestFactory.create_user("member1") member2 = TestFactory.create_user("member2") member3 = TestFactory.create_user("member3") TestFactory.create_project(member1, 'TestProject1', users=[member2.id, member3.id]) TestFactory.create_project(member2, 'TestProject2', users=[member1.id]) TestFactory.create_project(member3, 'TestProject3', users=[member1.id, member2.id]) projects = self.project_service.retrieve_projects_for_user(member1.id, 1)[0] self.assertEqual(len(projects), 3, "Projects not retrieved properly!") projects = self.project_service.retrieve_projects_for_user(member2.id, 1)[0] self.assertEqual(len(projects), 3, "Projects not retrieved properly!") projects = self.project_service.retrieve_projects_for_user(member3.id, 1)[0] self.assertEqual(len(projects), 2, "Projects not retrieved properly!")
def setUp(self): """ Sets up the environment for running the tests; cleans the database before testing and saves config file; creates a test user, a test project; creates burst, flow, operation and workflow services """ self.clean_database() self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user)
def setUp(self): _, self.connectivity = DatatypesFactory().create_connectivity() self.test_user = TestFactory.create_user(username="******") self.test_project = TestFactory.create_project(self.test_user, "Test") burst_conf = BurstConfiguration(self.test_project.id) burst_conf._simulator_configuration = self.CONF_HOPFIELD_HEUN_STOCH_RANGES burst_conf.prepare_after_load() burst_conf.simulator_configuration['connectivity'] = {'value': self.connectivity.gid} self.s_manager = SerializationManager(burst_conf) self.empty_manager = SerializationManager(BurstConfiguration(None))
def test_getmemberspage(self): """ Get the first page of the members page. """ users_count = dao.get_all_users(is_count=True) user = TestFactory.create_user('usr', 'pass') test_project = TestFactory.create_project(user, 'new_name') result = self.project_c.getmemberspage(0, test_project.id) self.assertEqual(result['usersMembers'], []) # Same users as before should be available since we created new one # as owned for the project. self.assertEqual(len(result['usersList']), users_count)
def setUp(self): """ Sets up the testing environment; saves config file; creates a test user, a test project; creates burst, operation, flow and workflow services """ self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user) self.workflow_service = WorkflowService() self.burst_service = BurstService() self.operation_service = OperationService() self.flow_service = FlowService()
def test_usermanagement_post_valid(self): """ Create a valid post and check that user is created. """ self.test_user.role = "ADMINISTRATOR" self.test_user = dao.store_entity(self.test_user) cherrypy.session[common.KEY_USER] = self.test_user TestFactory.create_user(username="******") TestFactory.create_user(username="******", validated=False) user_before_delete = dao.get_user_by_name("to_be_deleted") self.assertTrue(user_before_delete is not None) user_before_validation = dao.get_user_by_name("to_validate") self.assertFalse(user_before_validation.validated) data = {"delete_%i" % user_before_delete.id: True, "role_%i" % user_before_validation.id: "ADMINISTRATOR", "validate_%i" % user_before_validation.id: True} self.user_c.usermanagement(do_persist=True, **data) user_after_delete = dao.get_user_by_id(user_before_delete.id) self.assertTrue(user_after_delete is None, "User should be deleted.") user_after_validation = dao.get_user_by_id(user_before_validation.id) self.assertTrue(user_after_validation.validated, "User should be validated now.") self.assertTrue(user_after_validation.role == "ADMINISTRATOR", "Role has not changed.")
def setUp(self): """ Reset the database before each test. """ self.test_user = TestFactory.create_user("UserPM") self.test_project = TestFactory.import_default_project(self.test_user) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG()) self.assertTrue(self.sensors is not None)
def test_delete_entity_forget_commit(self): """ Commit should be done automatically if you forget for some reason to do so in case of new/update/deletes. """ all_users = dao.get_all_users() initial_user_count = len(all_users) if all_users is not None else 0 stored_user = TestFactory.create_user('username', 'password', 'mail', True, 'role') user_id = stored_user.id self._dao_delete_user_forget_commit(user_id) final_user_count = dao.get_all_users(is_count=True) self.assertEqual(initial_user_count, final_user_count, "Added user should have been deleted even without explicit commit call.." "Expected %s but got %s" % (initial_user_count, final_user_count))
def setUp(self): """ Prepare before each test. """ self.project_service = ProjectService() self.flow_service = FlowService() self.structure_helper = FilesHelper() self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user, "ProjectStructure") self.relevant_filter = StaticFiltersFactory.build_datatype_filters(single_filter=StaticFiltersFactory.RELEVANT_VIEW) self.full_filter = StaticFiltersFactory.build_datatype_filters(single_filter=StaticFiltersFactory.FULL_VIEW)
def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity and a surface; imports a CFF data-set """ self.test_user = TestFactory.create_user() self.test_project = TestFactory.import_default_project(self.test_user) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.region_mapping = TestFactory.get_entity(self.test_project, RegionMapping()) self.assertTrue(self.region_mapping is not None)
def setUp(self): """ Reset the database before each test. """ self.import_service = ImportService() self.flow_service = FlowService() self.project_service = ProjectService() self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user, name="GeneratedProject", description="test_desc") self.operation = TestFactory.create_operation(test_user=self.test_user, test_project=self.test_project) self.adapter_instance = TestFactory.create_adapter(test_project=self.test_project) TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.zip_path = None
def test_retrieve_projects_for_user(self): """ Test for retrieving the projects for a given user. One page only. """ initial_projects = self.project_service.retrieve_projects_for_user(self.test_user.id)[0] self.assertEqual(len(initial_projects), 0, "Database was not reset properly!") TestFactory.create_project(self.test_user, 'test_proj') TestFactory.create_project(self.test_user, 'test_proj1') TestFactory.create_project(self.test_user, 'test_proj2') user1 = TestFactory.create_user('another_user') TestFactory.create_project(user1, 'test_proj3') projects = self.project_service.retrieve_projects_for_user(self.test_user.id)[0] self.assertEqual(len(projects), 3, "Projects not retrieved properly!") for project in projects: self.assertNotEquals(project.name, "test_project3", "This project should not have been retrieved")
def setUp(self): """ Reset the database before each test. """ self.test_user = TestFactory.create_user("UserPM") self.test_project = TestFactory.create_project(self.test_user) zip_path = os.path.join(os.path.dirname(tvb_data.sensors.__file__), "eeg_brainstorm_65.txt") TestFactory.import_sensors(self.test_user, self.test_project, zip_path, Sensors_Importer.EEG_SENSORS) zip_path = os.path.join(os.path.dirname(tvb_data.surfaceData.__file__), "cortex_16384.zip") TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, CORTICAL, True) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG()) self.assertTrue(self.sensors is not None)
def setUp(self): self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(self.test_user) self.helper = FilesHelper()
def setUp(self): self.figure_service = FigureService() self.user = TestFactory.create_user() self.project = TestFactory.create_project(admin=self.user) self.files_helper = FilesHelper()
def setUp(self): """ Reset the database before each test. """ self.project_service = ProjectService() self.test_user = TestFactory.create_user()
def setUp(self): """ Reset the database before each test. """ self.test_user = TestFactory.create_user() self.test_project = TestFactory.create_project(admin=self.test_user)