def test_joins3_user_group(self): from aiida.orm.user import User from aiida.orm.querybuilder import QueryBuilder # Create another user new_email = "[email protected]" user = User(email=new_email) user.force_save() # Create a group that belongs to that user from aiida.orm.group import Group group = Group(name="node_group") group.dbgroup.user = user._dbuser group.store() # Search for the group of the user qb = QueryBuilder() qb.append(User, tag='user', filters={'id': {'==': user.id}}) qb.append(Group, belongs_to='user', filters={'id': {'==': group.id}}) self.assertEquals( qb.count(), 1, "The expected group that belongs to " "the selected user was not found.") # Search for the user that owns a group qb = QueryBuilder() qb.append(Group, tag='group', filters={'id': {'==': group.id}}) qb.append(User, owner_of='group', filters={'id': {'==': user.id}}) self.assertEquals( qb.count(), 1, "The expected user that owns the " "selected group was not found.")
def get_or_new_user(**kwargs): """find an existing user or instantiate a new one (unstored)""" from aiida.orm import User candidates = User.search_for_users(**kwargs) if candidates: user = candidates[0] created = False else: user = User(**kwargs) created = True return user, created
def test_workflow_info(self): """ This test checks that the workflow info is generate without any exceptions :return: """ # Assuming there is only one user dbuser = User.search_for_users(email=self.user_email)[0] # Creating a simple workflow & storing it a = WFTestEmpty() a.store() # Emulate the workflow list for w in get_workflow_list(all_states=True, user=dbuser): if not w.is_subworkflow(): get_workflow_info(w) # Create a workflow with sub-workflows and store it b = WFTestSimpleWithSubWF() b.store() # Emulate the workflow list for w in get_workflow_list(all_states=True, user=dbuser): if not w.is_subworkflow(): get_workflow_info(w) # Start the first workflow and perform a workflow list b.start() for w in get_workflow_list(all_states=True, user=dbuser): if not w.is_subworkflow(): get_workflow_info(w)
def init_db(self): """Initialise the database state for running of tests. Adds default user if necessary. """ from aiida.orm import User from aiida.cmdline.commands.cmd_user import set_default_user if not User.objects.get_default(): user_dict = get_user_dict(_DEFAULT_PROFILE_INFO) try: user = User(**user_dict) user.store() except exceptions.IntegrityError: # The user already exists, no problem user = User.objects.get(**user_dict) set_default_user(self._profile, user) User.objects.reset() # necessary to pick up new default user
def __clean_db_sqla(self): """Clean database for sqlalchemy backend""" from aiida.backends.sqlalchemy.tests.testbase import SqlAlchemyTests from aiida.backends.sqlalchemy import get_scoped_session from aiida.orm import User user = User.search_for_users(email=self.email)[0] new_user = User(email=user.email) new_user.first_name = user.first_name new_user.last_name = user.last_name new_user.institution = user.institution sqla_testcase = SqlAlchemyTests() sqla_testcase.test_session = get_scoped_session() sqla_testcase.clean_db() # that deleted our user, we need to recreate it new_user.force_save()
def test_listing_workflows(self): """ Test ensuring that the workflow listing works as expected. (Listing initialized & running workflows and not listing finished workflows or workflows with errors). """ # Assuming there is only one user dbuser = User.search_for_users(email=self.user_email)[0] # Creating a workflow & storing it a = WorkflowTestEmpty() a.store() # Setting manually the state to RUNNING. a.set_state(wf_states.RUNNING) # Getting all the available workflows of the current user # and checking if we got the right one. wfqs = get_workflow_list(all_states=True, user=dbuser) self.assertTrue(len(wfqs) == 1, "We expect one workflow") a_prime = wfqs[0].get_aiida_class() self.assertEqual(a.uuid, a_prime.uuid, "The uuid is not the expected " "one") # We ask all the running workflows. We should get one workflow. wfqs = get_workflow_list(all_states=True, user=dbuser) self.assertTrue(len(wfqs) == 1, "We expect one workflow") a_prime = wfqs[0].get_aiida_class() self.assertEqual(a.uuid, a_prime.uuid, "The uuid is not the expected " "one") # We change the state of the workflow to FINISHED. a.set_state(wf_states.FINISHED) # Getting all the available workflows of the current user # and checking if we got the right one. wfqs = get_workflow_list(all_states=True, user=dbuser) self.assertTrue(len(wfqs) == 1, "We expect one workflow") a_prime = wfqs[0].get_aiida_class() self.assertEqual(a.uuid, a_prime.uuid, "The uuid is not the expected " "one") # We ask all the running workflows. We should get zero results. wfqs = get_workflow_list(all_states=False, user=dbuser) self.assertTrue(len(wfqs) == 0, "We expect zero workflows") # We change the state of the workflow to INITIALIZED. a.set_state(wf_states.INITIALIZED) # We ask all the running workflows. We should get one workflow. wfqs = get_workflow_list(all_states=True, user=dbuser) self.assertTrue(len(wfqs) == 1, "We expect one workflow") a_prime = wfqs[0].get_aiida_class() self.assertEqual(a.uuid, a_prime.uuid, "The uuid is not the expected " "one") # We change the state of the workflow to ERROR. a.set_state(wf_states.ERROR) # We ask all the running workflows. We should get zero results. wfqs = get_workflow_list(all_states=False, user=dbuser) self.assertTrue(len(wfqs) == 0, "We expect zero workflows")
def workflow_list(self, *args): """ Return a list of workflows on screen """ from aiida.backends.utils import load_dbenv, is_dbenv_loaded if not is_dbenv_loaded(): load_dbenv() from aiida.backends.utils import get_workflow_list, get_automatic_user from aiida.orm.workflow import get_workflow_info from aiida.orm import User import argparse parser = argparse.ArgumentParser(prog=self.get_full_command_name(), description='List AiiDA workflows.') parser.add_argument('-s', '--short', action='store_true', help="show shorter output " "(only subworkflows and steps, no calculations)") parser.add_argument( '-a', '--all-states', action='store_true', help="show all existing " "AiiDA workflows, not only running ones", ) parser.add_argument( '-d', '--depth', metavar='M', action='store', type=int, default=16, help="add a filter " "to show only steps down to a depth of M levels in " "subworkflows (0 means only the parent " "workflows are shown)") parser.add_argument( '-p', '--past-days', metavar='N', action='store', type=int, help="add a " "filter to show only workflows created in the past N days") parser.add_argument( 'pks', type=int, nargs='*', help="a list of workflows to show. If empty, " "all running workflows are shown. If non-empty, " "automatically sets --all and ignores the -p option.") tab_size = 2 # how many spaces to use for indentation of subworkflows args = list(args) parsed_args = parser.parse_args(args) workflows = get_workflow_list(parsed_args.pks, user=User(dbuser=get_automatic_user()), all_states=parsed_args.all_states, n_days_ago=parsed_args.past_days) for w in workflows: if not w.is_subworkflow() or w.pk in parsed_args.pks: print "\n".join( get_workflow_info(w, tab_size=tab_size, short=parsed_args.short, depth=parsed_args.depth)) if not workflows: if parsed_args.all_states: print "# No workflows found" else: print "# No running workflows found"
def test_workflow_fast_kill(self): from aiida.cmdline.commands.workflow import Workflow as WfCmd params = dict() params['nmachine'] = 2 # Create a workflow with 2 subworkflows and start it head_wf = WFTestSimpleWithSubWF() head_wf.start() # Get the user dbuser = User.search_for_users(email=self.user_email)[0] wfl = get_workflow_list(user=dbuser) running_no = 0 for w in get_workflow_list(user=dbuser, all_states=True): if w.get_aiida_class().get_state() == wf_states.RUNNING: running_no += 1 self.assertEquals(running_no, 3, "Only 3 running workflows should be found") # Killing the head workflow wf_cmd = WfCmd() wf_cmd.workflow_kill(*[str(head_wf.pk), '-f', '-q']) # At this point no running workflow should be found running_no = 0 for w in get_workflow_list(user=dbuser, all_states=True): if w.get_aiida_class().get_state() == wf_states.RUNNING: running_no += 1 self.assertEquals(running_no, 0, "No running workflows should be found") self.assertNotEquals(get_all_running_steps(), 0, "At this point there will be running steps.") # Making the daemon to advance. This will automatically set # to FINISHED all the running steps that are (directly) under # a finished workflow manual_tick_all() self.assertEquals(len(list(get_all_running_steps())), 0, "At this point there should be no running steps.") running_no = 0 for w in get_workflow_list(user=dbuser, all_states=True): if w.get_aiida_class().get_state() == wf_states.RUNNING: running_no += 1 self.assertEquals( running_no, 0, "At this point there should be " "no running workflows.") # Make the daemon to advance a bit more and make sure that no # workflows resurrect. for _ in range(5): manual_tick_all() self.assertEquals(len(list(get_all_running_steps())), 0, "At this point there should be no running steps.") running_no = 0 for w in get_workflow_list(user=dbuser, all_states=True): if w.get_aiida_class().get_state() == wf_states.RUNNING: running_no += 1 self.assertEquals( running_no, 0, "At this point there should be " "no running workflows.")