Esempio n. 1
0
 def setUp(self):
     case_database.initialize()
     self.cases1 = {
         'case1': {
             'uid1': ['e1', 'e2', 'e3'],
             'uid2': ['e1']
         },
         'case2': {
             'uid1': ['e2', 'e3']
         }
     }
     self.cases_overlap = {
         'case2': {
             'uid3': ['e', 'b', 'c'],
             'uid4': ['d']
         },
         'case3': {
             'uid1': ['a', 'b']
         }
     }
     self.cases2 = {
         'case3': {
             'uid3': ['e', 'b', 'c'],
             'uid4': ['d']
         },
         'case4': {
             'uid1': ['a', 'b']
         }
     }
     self.cases_all = dict(self.cases1)
     self.cases_all.update(self.cases2)
Esempio n. 2
0
    def setUp(self):
        self.controller = walkoff.controller.controller
        self.controller.workflows = {}
        self.controller.load_playbooks(
            resource_collection=config.test_workflows_path)
        self.start = datetime.utcnow()

        database.initialize()
Esempio n. 3
0
    def setUp(self):
        self.empty_workflow_json = \
            {'actions': [],
             'name': 'test_name',
             'start': 'start',
             'branches': []}

        case_database.initialize()
Esempio n. 4
0
 def setUp(self):
     self.controller = walkoff.controller.controller
     self.controller.workflows = {}
     self.controller.load_playbooks(resource_collection=path.join(
         ".", "tests", "testWorkflows", "testGeneratedWorkflows"))
     self.controller.load_playbook(
         resource=path.join(config.test_workflows_path,
                            'simpleDataManipulationWorkflow.playbook'))
     self.id_tuple = ('simpleDataManipulationWorkflow',
                      'helloWorldWorkflow')
     self.testWorkflow = self.controller.get_workflow(*self.id_tuple)
     self.testWorkflow.set_execution_uid('some_uid')
     case_database.initialize()
Esempio n. 5
0
def run(host, port):
    from walkoff.core.multiprocessedexecutor.multiprocessedexecutor import spawn_worker_processes
    setup_logger()
    print_banner()
    pids = spawn_worker_processes()
    monkey.patch_all()

    from scripts.compose_api import compose_api
    compose_api()

    from walkoff.server import flaskserver
    flaskserver.running_context.controller.initialize_threading(pids=pids)
    # The order of these imports matter for initialization (should probably be fixed)

    import walkoff.case.database as case_database
    case_database.initialize()

    server = setup_server(flaskserver.app, host, port)
    server.serve_forever()
    def setUp(self):
        self.add_playbook_name = 'add_playbook'
        self.change_playbook_name = 'change_playbook'
        self.add_workflow_name = 'add_workflow'
        self.change_workflow_name = 'change_workflow'
        action_id = str(uuid4())
        self.empty_workflow_json = \
            {'actions': [
                {"app_name": "HelloWorld", "action_name": "helloWorld", "name": "helloworld", "id": action_id,
                 "arguments": []}],
                'name': self.add_workflow_name,
                'start': action_id,
                'branches': []}
        self.verb_lookup = {
            'get': self.get_with_status_check,
            'put': self.put_with_status_check,
            'post': self.post_with_status_check,
            'delete': self.delete_with_status_check,
            'patch': self.patch_with_status_check
        }

        case_database.initialize()
Esempio n. 7
0
 def setUp(self):
     walkoff.case.subscription.subscriptions = {}
     case_database.initialize()
Esempio n. 8
0
 def setUp(self):
     #monkey.patch_socket()
     walkoff.case.subscription.subscriptions = {}
     case_database.initialize()
 def setUp(self):
     MultiprocessedExecutor.pause_workflow = mock_pause_workflow
     MultiprocessedExecutor.resume_workflow = mock_resume_workflow
     case_database.initialize()
     walkoff.executiondb.schemas._schema_lookup[
         MockWorkflow] = MockWorkflowSchema
Esempio n. 10
0
 def setUp(self):
     case_database.initialize()
 def setUp(self):
     self.executor = multiprocessedexecutor.multiprocessedexecutor
     case_database.initialize()