ariatosca-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mxm...@apache.org
Subject [2/7] incubator-ariatosca git commit: Aria 21 reorder repository sturcutre
Date Wed, 16 Nov 2016 10:52:47 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/__init__.py
----------------------------------------------------------------------
diff --git a/tests/workflows/__init__.py b/tests/workflows/__init__.py
deleted file mode 100644
index fe04b2f..0000000
--- a/tests/workflows/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import api, builtin, core

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/api/__init__.py
----------------------------------------------------------------------
diff --git a/tests/workflows/api/__init__.py b/tests/workflows/api/__init__.py
deleted file mode 100644
index ae1e83e..0000000
--- a/tests/workflows/api/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/api/test_task.py
----------------------------------------------------------------------
diff --git a/tests/workflows/api/test_task.py b/tests/workflows/api/test_task.py
deleted file mode 100644
index 58f9760..0000000
--- a/tests/workflows/api/test_task.py
+++ /dev/null
@@ -1,150 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import pytest
-
-from aria import context
-from aria.workflows import api
-
-from ... import mock
-
-
-@pytest.fixture()
-def ctx():
-    """
-    Create the following graph in storage:
-    dependency_node <------ dependent_node
-    :return:
-    """
-    simple_context = mock.context.simple()
-    dependency_node = mock.models.get_dependency_node()
-    dependency_node_instance = mock.models.get_dependency_node_instance(
-        dependency_node=dependency_node)
-
-    relationship = mock.models.get_relationship(dependency_node)
-    relationship_instance = mock.models.get_relationship_instance(
-        relationship=relationship,
-        target_instance=dependency_node_instance
-    )
-
-    dependent_node = mock.models.get_dependent_node(relationship)
-    dependent_node_instance = mock.models.get_dependent_node_instance(
-        dependent_node=dependent_node,
-        relationship_instance=relationship_instance
-    )
-
-    simple_context.model.node.store(dependent_node)
-    simple_context.model.node.store(dependency_node)
-    simple_context.model.node_instance.store(dependent_node_instance)
-    simple_context.model.node_instance.store(dependency_node_instance)
-    simple_context.model.relationship.store(relationship)
-    simple_context.model.relationship_instance.store(relationship_instance)
-    simple_context.model.execution.store(mock.models.get_execution())
-    simple_context.model.deployment.store(mock.models.get_deployment())
-
-    return simple_context
-
-
-class TestOperationTask(object):
-
-    def test_node_operation_task_creation(self):
-        workflow_context = mock.context.simple()
-
-        operation_name = 'aria.interfaces.lifecycle.create'
-        op_details = {'operation': True}
-        node = mock.models.get_dependency_node()
-        node.operations[operation_name] = op_details
-        node_instance = mock.models.get_dependency_node_instance(dependency_node=node)
-        inputs = {'inputs': True}
-        max_attempts = 10
-        retry_interval = 10
-        ignore_failure = True
-
-        with context.workflow.current.push(workflow_context):
-            api_task = api.task.OperationTask.node_instance(
-                name=operation_name,
-                instance=node_instance,
-                inputs=inputs,
-                max_attempts=max_attempts,
-                retry_interval=retry_interval,
-                ignore_failure=ignore_failure)
-
-        assert api_task.name == '{0}.{1}'.format(operation_name, node_instance.id)
-        assert api_task.operation_mapping is True
-        assert api_task.actor == node_instance
-        assert api_task.inputs == inputs
-        assert api_task.retry_interval == retry_interval
-        assert api_task.max_attempts == max_attempts
-        assert api_task.ignore_failure == ignore_failure
-
-    def test_relationship_operation_task_creation(self):
-        workflow_context = mock.context.simple()
-
-        operation_name = 'aria.interfaces.relationship_lifecycle.preconfigure'
-        op_details = {'operation': True}
-        relationship = mock.models.get_relationship()
-        relationship.source_operations[operation_name] = op_details
-        relationship_instance = mock.models.get_relationship_instance(relationship=relationship)
-        inputs = {'inputs': True}
-        max_attempts = 10
-        retry_interval = 10
-
-        with context.workflow.current.push(workflow_context):
-            api_task = api.task.OperationTask.relationship_instance(
-                name=operation_name,
-                instance=relationship_instance,
-                operation_end=api.task.OperationTask.SOURCE_OPERATION,
-                inputs=inputs,
-                max_attempts=max_attempts,
-                retry_interval=retry_interval)
-
-        assert api_task.name == '{0}.{1}'.format(operation_name, relationship_instance.id)
-        assert api_task.operation_mapping is True
-        assert api_task.actor == relationship_instance
-        assert api_task.inputs == inputs
-        assert api_task.retry_interval == retry_interval
-        assert api_task.max_attempts == max_attempts
-
-    def test_operation_task_default_values(self):
-        workflow_context = mock.context.simple(task_ignore_failure=True)
-        with context.workflow.current.push(workflow_context):
-            model_task = api.task.OperationTask(
-                name='stub',
-                operation_mapping='',
-                actor=mock.models.get_dependency_node_instance())
-
-        assert model_task.inputs == {}
-        assert model_task.retry_interval == workflow_context._task_retry_interval
-        assert model_task.max_attempts == workflow_context._task_max_attempts
-        assert model_task.ignore_failure == workflow_context._task_ignore_failure
-
-
-class TestWorkflowTask(object):
-
-    def test_workflow_task_creation(self, ctx):
-
-        workspace = {}
-
-        mock_class = type('mock_class', (object,), {'test_attribute': True})
-
-        def sub_workflow(**kwargs):
-            workspace.update(kwargs)
-            return mock_class
-
-        with context.workflow.current.push(ctx):
-            workflow_task = api.task.WorkflowTask(sub_workflow, kwarg='workflow_kwarg')
-            assert workflow_task.graph is mock_class
-            assert workflow_task.test_attribute is True

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/api/test_task_graph.py
----------------------------------------------------------------------
diff --git a/tests/workflows/api/test_task_graph.py b/tests/workflows/api/test_task_graph.py
deleted file mode 100644
index 0ec0b0e..0000000
--- a/tests/workflows/api/test_task_graph.py
+++ /dev/null
@@ -1,745 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import pytest
-
-from aria.workflows.api import task_graph, task
-
-
-class MockTask(task.BaseTask):
-    def __init__(self):
-        super(MockTask, self).__init__(ctx={})
-
-
-@pytest.fixture
-def graph():
-    return task_graph.TaskGraph(name='mock-graph')
-
-
-class TestTaskGraphTasks(object):
-
-    def test_add_task(self, graph):
-        task = MockTask()
-        add_result = graph.add_tasks(task)
-        assert add_result == [task]
-        tasks = [t for t in graph.tasks]
-        assert len(tasks) == 1
-        assert tasks[0] == task
-
-    def test_add_empty_group(self, graph):
-        result = graph.add_tasks([])
-        assert result == []
-
-    def test_add_group(self, graph):
-        tasks = [MockTask(), MockTask(), MockTask()]
-        added_tasks = graph.add_tasks(*tasks)
-        assert added_tasks == tasks
-
-    def test_add_partially_existing_group(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        tasks = [MockTask(), task, MockTask()]
-        added_tasks = graph.add_tasks(*tasks)
-        assert added_tasks == [tasks[0], tasks[2]]
-
-    def test_add_recursively_group(self, graph):
-        recursive_group = [MockTask(), MockTask()]
-        tasks = [MockTask(), recursive_group, MockTask()]
-        added_tasks = graph.add_tasks(tasks)
-        assert added_tasks == [tasks[0], recursive_group[0], recursive_group[1], tasks[2]]
-
-    def test_add_existing_task(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        # adding a task already in graph - should have no effect, and return False
-        add_result = graph.add_tasks(task)
-        assert add_result == []
-        tasks = [t for t in graph.tasks]
-        assert len(tasks) == 1
-        assert tasks[0] == task
-
-    def test_remove_task(self, graph):
-        task = MockTask()
-        other_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(other_task)
-        graph.remove_tasks(other_task)
-        tasks = [t for t in graph.tasks]
-        assert len(tasks) == 1
-        assert tasks[0] == task
-
-    def test_remove_tasks_with_dependency(self, graph):
-        task = MockTask()
-        dependent_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(dependent_task)
-        graph.add_dependency(dependent_task, task)
-        remove_result = graph.remove_tasks(dependent_task)
-        assert remove_result == [dependent_task]
-        tasks = [t for t in graph.tasks]
-        assert len(tasks) == 1
-        assert tasks[0] == task
-        # asserting no dependencies are left for the dependent task
-        assert len(list(graph.get_dependencies(task))) == 0
-
-    def test_remove_empty_group(self, graph):
-        result = graph.remove_tasks([])
-        assert result == []
-
-    def test_remove_group(self, graph):
-        tasks = [MockTask(), MockTask(), MockTask()]
-        graph.add_tasks(*tasks)
-        removed_tasks = graph.remove_tasks(*tasks)
-        assert removed_tasks == tasks
-
-    def test_remove_partially_existing_group(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        tasks = [MockTask(), task, MockTask()]
-        removed_tasks = graph.remove_tasks(*tasks)
-        assert removed_tasks == [task]
-
-    def test_remove_recursively_group(self, graph):
-        recursive_group = [MockTask(), MockTask()]
-        tasks = [MockTask(), recursive_group, MockTask()]
-        graph.add_tasks(tasks)
-        removed_tasks = graph.remove_tasks(tasks)
-        assert removed_tasks == [tasks[0], recursive_group[0], recursive_group[1], tasks[2]]
-
-    def test_remove_nonexistent_task(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        # removing a task not in graph - should have no effect, and return False
-        remove_result = graph.remove_tasks(task_not_in_graph)
-        assert remove_result == []
-        tasks = [t for t in graph.tasks]
-        assert len(tasks) == 1
-        assert tasks[0] == task
-
-    def test_has_task(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        assert graph.has_tasks(task) is True
-
-    def test_has_nonexistent_task(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        assert graph.has_tasks(task_not_in_graph) is False
-
-    def test_has_empty_group(self, graph):
-        # the "empty task" is in the graph
-        assert graph.has_tasks([]) is True
-
-    def test_has_group(self, graph):
-        tasks = [MockTask(), MockTask(), MockTask()]
-        graph.add_tasks(*tasks)
-        assert graph.has_tasks(*tasks) is True
-
-    def test_has_partially_existing_group(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        tasks = [MockTask(), task, MockTask()]
-        assert graph.has_tasks(tasks) is False
-
-    def test_has_recursively_group(self, graph):
-        recursive_group = [MockTask(), MockTask()]
-        tasks = [MockTask(), recursive_group, MockTask()]
-        graph.add_tasks(tasks)
-        assert graph.has_tasks(tasks) is True
-
-    def test_get_task(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        assert graph.get_task(task.id) == task
-
-    def test_get_nonexistent_task(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            graph.get_task(task_not_in_graph.id)
-
-
-class TestTaskGraphGraphTraversal(object):
-
-    def test_tasks_iteration(self, graph):
-        task = MockTask()
-        other_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(other_task)
-        tasks = [t for t in graph.tasks]
-        assert set(tasks) == set([task, other_task])
-
-    def test_get_dependents(self, graph):
-        task = MockTask()
-        dependent_task_1 = MockTask()
-        dependent_task_2 = MockTask()
-        transitively_dependent_task = MockTask()
-
-        graph.add_tasks(task)
-        graph.add_tasks(dependent_task_1)
-        graph.add_tasks(dependent_task_2)
-        graph.add_tasks(transitively_dependent_task)
-
-        graph.add_dependency(dependent_task_1, task)
-        graph.add_dependency(dependent_task_2, task)
-        graph.add_dependency(transitively_dependent_task, dependent_task_2)
-
-        dependent_tasks = list(graph.get_dependents(task))
-        # transitively_dependent_task not expected to appear in the result
-        assert set(dependent_tasks) == set([dependent_task_1, dependent_task_2])
-
-    def test_get_task_empty_dependents(self, graph):
-        task = MockTask()
-        other_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(other_task)
-        dependent_tasks = list(graph.get_dependents(task))
-        assert len(dependent_tasks) == 0
-
-    def test_get_nonexistent_task_dependents(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            list(graph.get_dependents(task_not_in_graph))
-
-    def test_get_dependencies(self, graph):
-        task = MockTask()
-        dependency_task_1 = MockTask()
-        dependency_task_2 = MockTask()
-        transitively_dependency_task = MockTask()
-
-        graph.add_tasks(task)
-        graph.add_tasks(dependency_task_1)
-        graph.add_tasks(dependency_task_2)
-        graph.add_tasks(transitively_dependency_task)
-
-        graph.add_dependency(task, dependency_task_1)
-        graph.add_dependency(task, dependency_task_2)
-        graph.add_dependency(dependency_task_2, transitively_dependency_task)
-
-        dependency_tasks = list(graph.get_dependencies(task))
-        # transitively_dependency_task not expected to appear in the result
-        assert set(dependency_tasks) == set([dependency_task_1, dependency_task_2])
-
-    def test_get_task_empty_dependencies(self, graph):
-        task = MockTask()
-        other_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(other_task)
-        dependency_tasks = list(graph.get_dependencies(task))
-        assert len(dependency_tasks) == 0
-
-    def test_get_nonexistent_task_dependencies(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            list(graph.get_dependencies(task_not_in_graph))
-
-
-class TestTaskGraphDependencies(object):
-
-    def test_add_dependency(self, graph):
-        task = MockTask()
-        dependency_task = MockTask()
-        unrelated_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(dependency_task)
-        graph.add_tasks(unrelated_task)
-        graph.add_dependency(task, dependency_task)
-        add_result = graph.has_dependency(task, dependency_task)
-        assert add_result is True
-        dependency_tasks = list(graph.get_dependencies(task))
-        assert len(dependency_tasks) == 1
-        assert dependency_tasks[0] == dependency_task
-
-    def test_add_existing_dependency(self, graph):
-        task = MockTask()
-        dependency_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(dependency_task)
-        graph.add_dependency(task, dependency_task)
-        add_result = graph.has_dependency(task, dependency_task)
-        # adding a dependency already in graph - should have no effect, and return False
-        assert add_result is True
-        graph.add_dependency(task, dependency_task)
-        add_result = graph.has_dependency(task, dependency_task)
-        assert add_result is True
-        dependency_tasks = list(graph.get_dependencies(task))
-        assert len(dependency_tasks) == 1
-        assert dependency_tasks[0] == dependency_task
-
-    def test_add_dependency_nonexistent_dependent(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            graph.add_dependency(task_not_in_graph, task)
-
-    def test_add_dependency_nonexistent_dependency(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            graph.add_dependency(task, task_not_in_graph)
-
-    def test_add_dependency_empty_dependent(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        # expecting add_dependency result to be False - no dependency has been created
-        assert set(graph.tasks) == set((task,))
-
-    def test_add_dependency_empty_dependency(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        # expecting add_dependency result to be False - no dependency has been created
-        assert set(graph.tasks) == set((task,))
-
-    def test_add_dependency_dependent_group(self, graph):
-        task = MockTask()
-        group_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        graph.add_tasks(*group_tasks)
-        graph.add_dependency(group_tasks, task)
-        assert graph.has_dependency(group_tasks[0], task) is True
-        assert graph.has_dependency(group_tasks[1], task) is True
-        assert graph.has_dependency(group_tasks[2], task) is True
-
-    def test_add_dependency_dependency_group(self, graph):
-        task = MockTask()
-        group_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        graph.add_tasks(*group_tasks)
-        graph.add_dependency(task, group_tasks)
-        assert graph.has_dependency(task, group_tasks[0]) is True
-        assert graph.has_dependency(task, group_tasks[1]) is True
-        assert graph.has_dependency(task, group_tasks[2]) is True
-
-    def test_add_dependency_between_groups(self, graph):
-        group_1_tasks = [MockTask() for _ in xrange(3)]
-        group_2_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(*group_1_tasks)
-        graph.add_tasks(*group_2_tasks)
-        graph.add_dependency(group_1_tasks, group_2_tasks)
-        for group_2_task in group_2_tasks:
-            assert graph.has_dependency(group_1_tasks[0], group_2_task) is True
-            assert graph.has_dependency(group_1_tasks[1], group_2_task) is True
-            assert graph.has_dependency(group_1_tasks[2], group_2_task) is True
-
-    def test_add_dependency_dependency_group_with_some_existing_dependencies(self, graph):
-        task = MockTask()
-        group_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        graph.add_tasks(*group_tasks)
-        # adding a dependency on a specific task manually,
-        # before adding a dependency on the whole parallel
-        graph.add_dependency(task, group_tasks[1])
-        graph.add_dependency(task, group_tasks)
-        assert graph.has_dependency(task, group_tasks[0]) is True
-        assert graph.has_dependency(task, group_tasks[1]) is True
-        assert graph.has_dependency(task, group_tasks[2]) is True
-
-    def test_add_existing_dependency_between_groups(self, graph):
-        group_1_tasks = [MockTask() for _ in xrange(3)]
-        group_2_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(*group_1_tasks)
-        graph.add_tasks(*group_2_tasks)
-        graph.add_dependency(group_1_tasks, group_2_tasks)
-        add_result = graph.has_dependency(group_1_tasks, group_2_tasks)
-        assert add_result is True
-        # adding a dependency already in graph - should have no effect, and return False
-        graph.add_dependency(group_1_tasks, group_2_tasks)
-        add_result = graph.has_dependency(group_1_tasks, group_2_tasks)
-        assert add_result is True
-        for group_2_task in group_2_tasks:
-            assert graph.has_dependency(group_1_tasks[0], group_2_task) is True
-            assert graph.has_dependency(group_1_tasks[1], group_2_task) is True
-            assert graph.has_dependency(group_1_tasks[2], group_2_task) is True
-
-    def test_has_dependency(self, graph):
-        task = MockTask()
-        dependency_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(dependency_task)
-        graph.add_dependency(task, dependency_task)
-        assert graph.has_dependency(task, dependency_task) is True
-
-    def test_has_nonexistent_dependency(self, graph):
-        task = MockTask()
-        other_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(other_task)
-        assert graph.has_dependency(task, other_task) is False
-
-    def test_has_dependency_nonexistent_dependent(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            graph.has_dependency(task_not_in_graph, task)
-
-    def test_has_dependency_nonexistent_dependency(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            graph.has_dependency(task, task_not_in_graph)
-
-    def test_has_dependency_empty_dependent(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        # expecting has_dependency result to be False - dependency in an empty form
-        assert graph.has_dependency([], task) is False
-
-    def test_has_dependency_empty_dependency(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        # expecting has_dependency result to be True - dependency in an empty form
-        assert graph.has_dependency(task, []) is False
-
-    def test_has_dependency_dependent_group(self, graph):
-        task = MockTask()
-        group_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        graph.add_tasks(*group_tasks)
-        assert graph.has_dependency(group_tasks, task) is False
-        graph.add_dependency(group_tasks, task)
-        assert graph.has_dependency(group_tasks, task) is True
-
-    def test_has_dependency_dependency_parallel(self, graph):
-        task = MockTask()
-        group_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        graph.add_tasks(*group_tasks)
-        assert graph.has_dependency(task, group_tasks) is False
-        graph.add_dependency(task, group_tasks)
-        assert graph.has_dependency(task, group_tasks) is True
-
-    def test_has_dependency_between_groups(self, graph):
-        group_1_tasks = [MockTask() for _ in xrange(3)]
-        group_2_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(*group_1_tasks)
-        graph.add_tasks(*group_2_tasks)
-        assert graph.has_dependency(group_2_tasks, group_1_tasks) is False
-        graph.add_dependency(group_2_tasks, group_1_tasks)
-        assert graph.has_dependency(group_2_tasks, group_1_tasks) is True
-
-    def test_has_dependency_dependency_parallel_with_some_existing_dependencies(self, graph):
-        task = MockTask()
-        parallel_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        parallel = graph.add_tasks(*parallel_tasks)
-        graph.add_dependency(task, parallel_tasks[1])
-        # only a partial dependency exists - has_dependency is expected to return False
-        assert graph.has_dependency(task, parallel) is False
-
-    def test_has_nonexistent_dependency_between_groups(self, graph):
-        group_1_tasks = [MockTask() for _ in xrange(3)]
-        group_2_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(*group_1_tasks)
-        graph.add_tasks(*group_2_tasks)
-        assert graph.has_dependency(group_1_tasks, group_2_tasks) is False
-
-    def test_remove_dependency(self, graph):
-        task = MockTask()
-        dependency_task = MockTask()
-        another_dependent_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(dependency_task)
-        graph.add_tasks(another_dependent_task)
-        graph.add_dependency(task, dependency_task)
-        graph.add_dependency(another_dependent_task, dependency_task)
-
-        graph.remove_dependency(task, dependency_task)
-        remove_result = graph.has_dependency(task, dependency_task)
-        assert remove_result is False
-        assert graph.has_dependency(task, dependency_task) is False
-        assert graph.has_dependency(another_dependent_task, dependency_task) is True
-
-    def test_remove_nonexistent_dependency(self, graph):
-        task = MockTask()
-        dependency_task = MockTask()
-        graph.add_tasks(task)
-        graph.add_tasks(dependency_task)
-        # removing a dependency not in graph - should have no effect, and return False
-        graph.remove_dependency(task, dependency_task)
-        remove_result = graph.has_dependency(task, dependency_task)
-        assert remove_result is False
-        tasks = [t for t in graph.tasks]
-        assert set(tasks) == set([task, dependency_task])
-
-    def test_remove_dependency_nonexistent_dependent(self, graph):
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            graph.remove_dependency(task_not_in_graph, task)
-
-    def test_remove_dependency_nonexistent_dependency(self, graph):
-        # in this test the dependency *task* is not in the graph, not just the dependency itself
-        task = MockTask()
-        task_not_in_graph = MockTask()
-        graph.add_tasks(task)
-        with pytest.raises(task_graph.TaskNotInGraphError):
-            graph.remove_dependency(task, task_not_in_graph)
-
-    def test_remove_dependency_empty_dependent(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        # expecting remove_dependency result to be False - no dependency has been created
-        graph.remove_dependency([], task)
-        assert set(graph.tasks) == set((task,))
-
-    def test_remove_dependency_empty_dependency(self, graph):
-        task = MockTask()
-        graph.add_tasks(task)
-        # expecting remove_dependency result to be False - no dependency has been created
-        graph.remove_dependency(task, [])
-        assert set(graph.tasks) == set((task,))
-
-    def test_remove_dependency_dependent_group(self, graph):
-        task = MockTask()
-        group_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        graph.add_tasks(*group_tasks)
-        graph.add_dependency(group_tasks, task)
-        graph.remove_dependency(group_tasks, task)
-        remove_result = graph.has_dependency(group_tasks, task)
-        assert remove_result is False
-        assert graph.has_dependency(group_tasks[0], task) is False
-        assert graph.has_dependency(group_tasks[1], task) is False
-        assert graph.has_dependency(group_tasks[2], task) is False
-
-    def test_remove_dependency_dependency_group(self, graph):
-        task = MockTask()
-        group_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        graph.add_tasks(*group_tasks)
-        graph.add_dependency(task, group_tasks)
-        graph.remove_dependency(task, group_tasks)
-        remove_result = graph.has_dependency(task, group_tasks)
-        assert remove_result is False
-        assert graph.has_dependency(task, group_tasks[0]) is False
-        assert graph.has_dependency(task, group_tasks[1]) is False
-        assert graph.has_dependency(task, group_tasks[2]) is False
-
-    def test_remove_dependency_between_groups(self, graph):
-        group_1_tasks = [MockTask() for _ in xrange(3)]
-        group_2_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(*group_1_tasks)
-        graph.add_tasks(*group_2_tasks)
-        graph.add_dependency(group_2_tasks, group_1_tasks)
-        graph.remove_dependency(group_2_tasks, group_1_tasks)
-        remove_result = graph.has_dependency(group_2_tasks, group_1_tasks)
-        assert remove_result is False
-        for group_2_task in group_2_tasks:
-            assert graph.has_dependency(group_2_task, group_1_tasks[0]) is False
-            assert graph.has_dependency(group_2_task, group_1_tasks[1]) is False
-            assert graph.has_dependency(group_2_task, group_1_tasks[2]) is False
-
-    def test_remove_dependency_dependency_group_with_some_existing_dependencies(self, graph):
-        task = MockTask()
-        group_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(task)
-        graph.add_tasks(*group_tasks)
-        graph.add_dependency(task, group_tasks[1])
-        graph.remove_dependency(task, group_tasks)
-        remove_result = graph.has_dependency(task, group_tasks)
-        # only a partial dependency exists - remove_dependency is expected to return False
-        assert remove_result is False
-        # no dependencies are expected to have changed
-        assert graph.has_dependency(task, group_tasks[0]) is False
-        assert graph.has_dependency(task, group_tasks[1]) is True
-        assert graph.has_dependency(task, group_tasks[2]) is False
-
-    def test_remove_nonexistent_dependency_between_groups(self, graph):
-        group_1_tasks = [MockTask() for _ in xrange(3)]
-        group_2_tasks = [MockTask() for _ in xrange(3)]
-        graph.add_tasks(*group_1_tasks)
-        graph.add_tasks(*group_2_tasks)
-        # removing a dependency not in graph - should have no effect, and return False
-        graph.remove_dependency(group_2_tasks, group_1_tasks)
-        remove_result = graph.has_dependency(group_2_tasks, group_1_tasks)
-        assert remove_result is False
-
-    # nested tests
-
-    def test_group_with_nested_sequence(self, graph):
-        all_tasks = [MockTask() for _ in xrange(5)]
-        graph.add_tasks(all_tasks[0],
-                        graph.sequence(all_tasks[1], all_tasks[2], all_tasks[3]),
-                        all_tasks[4])
-        assert set(graph.tasks) == set(all_tasks)
-
-        # tasks[2] and tasks[3] should each have a single dependency; the rest should have none
-        assert len(list(graph.get_dependencies(all_tasks[0]))) == 0
-        assert len(list(graph.get_dependencies(all_tasks[1]))) == 0
-        assert set(graph.get_dependencies(all_tasks[2])) == set([all_tasks[1]])
-        assert set(graph.get_dependencies(all_tasks[3])) == set([all_tasks[2]])
-        assert len(list(graph.get_dependencies(all_tasks[4]))) == 0
-
-    def test_group_with_nested_group(self, graph):
-        tasks = [MockTask() for _ in xrange(5)]
-        graph.add_tasks(tasks[0], (tasks[1], tasks[2], tasks[3]), tasks[4])
-        graph_tasks = [t for t in graph.tasks]
-        assert set(graph_tasks) == set(tasks)
-        # none of the tasks should have any dependencies
-        for i in xrange(len(tasks)):
-            assert len(list(graph.get_dependencies(tasks[i]))) == 0
-
-    def test_group_with_recursively_nested_group(self, graph):
-        recursively_nested_tasks = [MockTask(), MockTask(), MockTask()]
-        nested_tasks = [MockTask(), MockTask(), MockTask(), recursively_nested_tasks]
-        tasks = [MockTask(), MockTask(), MockTask(), nested_tasks]
-        graph.add_tasks(*tasks)
-
-        assert set(graph.tasks) == set(tasks[:3] + nested_tasks[:3] + recursively_nested_tasks)
-        for tasks_list in [tasks, nested_tasks, recursively_nested_tasks]:
-            for i in xrange(len(tasks_list[:3])):
-                assert len(list(graph.get_dependencies(tasks_list[i]))) == 0
-
-    def test_group_with_recursively_nested_group_and_interdependencies(self, graph):
-        recursively_nested_tasks = [MockTask(), MockTask(), MockTask()]
-        nested_tasks = [MockTask(), MockTask(), MockTask(), recursively_nested_tasks]
-        tasks = [MockTask(), MockTask(), MockTask(), nested_tasks]
-        graph.add_tasks(*tasks)
-
-        graph.add_dependency(tasks[2], nested_tasks[2])
-        graph.add_dependency(nested_tasks[1], recursively_nested_tasks[0])
-        graph.add_dependency(recursively_nested_tasks[1], tasks[0])
-
-        assert set(graph.tasks) == set(tasks[:3] + nested_tasks[:3] + recursively_nested_tasks)
-        assert set(graph.get_dependencies(tasks[0])) == set()
-        assert set(graph.get_dependencies(tasks[1])) == set()
-        assert set(graph.get_dependencies(tasks[2])) == set([nested_tasks[2]])
-
-        assert set(graph.get_dependencies(nested_tasks[0])) == set()
-        assert set(graph.get_dependencies(nested_tasks[1])) == set([recursively_nested_tasks[0]])
-        assert set(graph.get_dependencies(nested_tasks[2])) == set()
-
-        assert set(graph.get_dependencies(recursively_nested_tasks[0])) == set()
-        assert set(graph.get_dependencies(recursively_nested_tasks[1])) == set([tasks[0]])
-        assert set(graph.get_dependencies(recursively_nested_tasks[2])) == set()
-
-
-class TestTaskGraphSequence(object):
-
-    def test_sequence(self, graph):
-        tasks = [MockTask(), MockTask(), MockTask()]
-        graph.sequence(*tasks)
-        graph_tasks = [t for t in graph.tasks]
-        assert set(graph_tasks) == set(tasks)
-        assert len(list(graph.get_dependencies(tasks[0]))) == 0
-        assert set(graph.get_dependencies(tasks[1])) == set([tasks[0]])
-        assert set(graph.get_dependencies(tasks[2])) == set([tasks[1]])
-
-    def test_sequence_with_some_tasks_and_dependencies_already_in_graph(self, graph):
-        # tests both that tasks which werent previously in graph get inserted, and
-        # that existing tasks don't get re-added to graph
-        tasks = [MockTask(), MockTask(), MockTask()]
-        # insert some tasks and dependencies to the graph
-        graph.add_tasks(tasks[1])
-        graph.add_tasks(tasks[2])
-        graph.add_dependency(tasks[2], tasks[1])
-
-        graph.sequence(*tasks)
-        graph_tasks = [t for t in graph.tasks]
-        assert set(graph_tasks) == set(tasks)
-        assert len(list(graph.get_dependencies(tasks[0]))) == 0
-        assert set(graph.get_dependencies(tasks[1])) == set([tasks[0]])
-        assert set(graph.get_dependencies(tasks[2])) == set([tasks[1]])
-
-    def test_sequence_with_nested_sequence(self, graph):
-        tasks = [MockTask() for _ in xrange(5)]
-        graph.sequence(tasks[0], graph.sequence(tasks[1], tasks[2], tasks[3]), tasks[4])
-        graph_tasks = [t for t in graph.tasks]
-        assert set(graph_tasks) == set(tasks)
-        # first task should have no dependencies
-        assert len(list(graph.get_dependencies(tasks[0]))) == 0
-        assert len(list(graph.get_dependencies(tasks[1]))) == 1
-        assert len(list(graph.get_dependencies(tasks[2]))) == 2
-        assert len(list(graph.get_dependencies(tasks[3]))) == 2
-        assert len(list(graph.get_dependencies(tasks[4]))) == 3
-
-    def test_sequence_with_nested_group(self, graph):
-        tasks = [MockTask() for _ in xrange(5)]
-        graph.sequence(tasks[0], (tasks[1], tasks[2], tasks[3]), tasks[4])
-        graph_tasks = [t for t in graph.tasks]
-        assert set(graph_tasks) == set(tasks)
-        # first task should have no dependencies
-        assert len(list(graph.get_dependencies(tasks[0]))) == 0
-        # rest of the tasks (except last) should have a single dependency - the first task
-        for i in xrange(1, 4):
-            assert set(graph.get_dependencies(tasks[i])) == set([tasks[0]])
-        # last task should have have a dependency on all tasks except for the first one
-        assert set(graph.get_dependencies(tasks[4])) == set([tasks[1], tasks[2], tasks[3]])
-
-    def test_sequence_with_recursively_nested_group(self, graph):
-        recursively_nested_group = [MockTask(), MockTask()]
-        nested_group = [MockTask(), recursively_nested_group, MockTask()]
-        sequence_tasks = [MockTask(), nested_group, MockTask()]
-
-        graph.sequence(*sequence_tasks)
-        graph_tasks = [t for t in graph.tasks]
-        assert set(graph_tasks) == set([sequence_tasks[0], nested_group[0],
-                                        recursively_nested_group[0], recursively_nested_group[1],
-                                        nested_group[2], sequence_tasks[2]])
-
-        assert list(graph.get_dependencies(nested_group[0])) == [sequence_tasks[0]]
-        assert list(graph.get_dependencies(recursively_nested_group[0])) == [sequence_tasks[0]]
-        assert list(graph.get_dependencies(recursively_nested_group[1])) == [sequence_tasks[0]]
-        assert list(graph.get_dependencies(nested_group[2])) == [sequence_tasks[0]]
-
-        assert list(graph.get_dependents(nested_group[0])) == [sequence_tasks[2]]
-        assert list(graph.get_dependents(recursively_nested_group[0])) == [sequence_tasks[2]]
-        assert list(graph.get_dependents(recursively_nested_group[1])) == [sequence_tasks[2]]
-        assert list(graph.get_dependents(nested_group[2])) == [sequence_tasks[2]]
-
-    def test_sequence_with_empty_group(self, graph):
-        tasks = [MockTask(), [], MockTask()]
-        graph.sequence(*tasks)
-        graph_tasks = set([t for t in graph.tasks])
-        assert graph_tasks == set([tasks[0], tasks[2]])
-        assert list(graph.get_dependents(tasks[0])) == [tasks[2]]
-        assert list(graph.get_dependencies(tasks[2])) == [tasks[0]]
-
-    def test_sequence_with_recursively_nested_sequence_and_interdependencies(self, graph):
-        recursively_nested_tasks = list(graph.sequence(MockTask(), MockTask(), MockTask()))
-        nested_tasks = list(graph.sequence(MockTask(),
-                                           MockTask(),
-                                           MockTask(),
-                                           recursively_nested_tasks))
-        tasks = [MockTask(), MockTask(), MockTask(), nested_tasks]
-        graph.sequence(*tasks)
-
-        assert set(graph.tasks) == set(tasks[:3] + nested_tasks[:3] + recursively_nested_tasks)
-        assert set(graph.get_dependencies(tasks[0])) == set()
-        for i in xrange(1, len(tasks[:-1])):
-            assert set(graph.get_dependencies(tasks[i])) == set([tasks[i - 1]])
-
-        assert set(graph.get_dependencies(nested_tasks[0])) == set([tasks[2]])
-        for i in xrange(1, len(nested_tasks[:-1])):
-            assert set(graph.get_dependencies(nested_tasks[i])) == \
-                   set([tasks[2], nested_tasks[i-1]])
-
-        assert set(graph.get_dependencies(recursively_nested_tasks[0])) == \
-               set([tasks[2], nested_tasks[2]])
-        for i in xrange(1, len(recursively_nested_tasks[:-1])):
-            assert set(graph.get_dependencies(recursively_nested_tasks[i])) == \
-                   set([tasks[2], nested_tasks[2], recursively_nested_tasks[i-1]])

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/builtin/__init__.py
----------------------------------------------------------------------
diff --git a/tests/workflows/builtin/__init__.py b/tests/workflows/builtin/__init__.py
deleted file mode 100644
index c82c024..0000000
--- a/tests/workflows/builtin/__init__.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-from ... import mock
-
-def assert_node_install_operations(operations, with_relationships=False):
-    if with_relationships:
-        all_operations = [
-            'aria.interfaces.lifecycle.create',
-            'aria.interfaces.relationship_lifecycle.preconfigure',
-            'aria.interfaces.relationship_lifecycle.preconfigure',
-            'aria.interfaces.lifecycle.configure',
-            'aria.interfaces.relationship_lifecycle.postconfigure',
-            'aria.interfaces.relationship_lifecycle.postconfigure',
-            'aria.interfaces.lifecycle.start',
-            'aria.interfaces.relationship_lifecycle.establish',
-            'aria.interfaces.relationship_lifecycle.establish',
-        ]
-
-        for i, operation in enumerate(operations):
-            assert operation.name.startswith(all_operations[i])
-    else:
-        for i, operation in enumerate(operations):
-            assert operation.name.startswith(mock.operations.NODE_OPERATIONS_INSTALL[i])
-
-
-def assert_node_uninstall_operations(operations, with_relationships=False):
-    if with_relationships:
-        all_operations = [
-            'aria.interfaces.lifecycle.stop',
-            'aria.interfaces.relationship_lifecycle.unlink',
-            'aria.interfaces.relationship_lifecycle.unlink',
-            'aria.interfaces.lifecycle.delete',
-        ]
-
-        for i, operation in enumerate(operations):
-            assert operation.name.startswith(all_operations[i])
-    else:
-        for i, operation in enumerate(operations):
-            assert operation.name.startswith(mock.operations.NODE_OPERATIONS_UNINSTALL[i])
-
-
-def ctx_with_basic_graph():
-    """
-    Create the following graph in storage:
-    dependency_node <------ dependent_node
-    :return:
-    """
-    simple_context = mock.context.simple()
-    dependency_node = mock.models.get_dependency_node()
-    dependency_node_instance = mock.models.get_dependency_node_instance(
-        dependency_node=dependency_node)
-
-    relationship = mock.models.get_relationship(dependency_node)
-    relationship_instance = mock.models.get_relationship_instance(
-        relationship=relationship,
-        target_instance=dependency_node_instance
-    )
-
-    dependent_node = mock.models.get_dependent_node(relationship)
-    dependent_node_instance = mock.models.get_dependent_node_instance(
-        dependent_node=dependent_node,
-        relationship_instance=relationship_instance
-    )
-
-    simple_context.model.node.store(dependent_node)
-    simple_context.model.node.store(dependency_node)
-    simple_context.model.node_instance.store(dependent_node_instance)
-    simple_context.model.node_instance.store(dependency_node_instance)
-    simple_context.model.relationship.store(relationship)
-    simple_context.model.relationship_instance.store(relationship_instance)
-
-    return simple_context

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/builtin/test_execute_operation.py
----------------------------------------------------------------------
diff --git a/tests/workflows/builtin/test_execute_operation.py b/tests/workflows/builtin/test_execute_operation.py
deleted file mode 100644
index 0bd59ed..0000000
--- a/tests/workflows/builtin/test_execute_operation.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import pytest
-
-from aria.workflows.api import task
-from aria.workflows.builtin.execute_operation import execute_operation
-
-from ... import mock
-from . import ctx_with_basic_graph
-
-
-@pytest.fixture
-def ctx():
-    return ctx_with_basic_graph()
-
-
-def test_execute_operation(ctx):
-    operation_name = mock.operations.NODE_OPERATIONS_INSTALL[0]
-    node_instance_id = 'dependency_node_instance'
-
-    execute_tasks = list(
-        task.WorkflowTask(
-            execute_operation,
-            ctx=ctx,
-            operation=operation_name,
-            operation_kwargs={},
-            allow_kwargs_override=False,
-            run_by_dependency_order=False,
-            type_names=[],
-            node_ids=[],
-            node_instance_ids=[node_instance_id]
-        ).topological_order()
-    )
-
-    assert len(execute_tasks) == 1
-    assert execute_tasks[0].name == '{0}.{1}'.format(operation_name, node_instance_id)
-
-# TODO: add more scenarios

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/builtin/test_heal.py
----------------------------------------------------------------------
diff --git a/tests/workflows/builtin/test_heal.py b/tests/workflows/builtin/test_heal.py
deleted file mode 100644
index edffe2c..0000000
--- a/tests/workflows/builtin/test_heal.py
+++ /dev/null
@@ -1,88 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import pytest
-
-from aria.workflows.api import task
-from aria.workflows.builtin.heal import heal
-
-from . import (assert_node_install_operations,
-               assert_node_uninstall_operations,
-               ctx_with_basic_graph)
-
-
-@pytest.fixture
-def ctx():
-    return ctx_with_basic_graph()
-
-
-def test_heal_dependent_node(ctx):
-    heal_graph = task.WorkflowTask(heal, ctx=ctx, node_instance_id='dependent_node_instance')
-
-    assert len(list(heal_graph.tasks)) == 2
-    uninstall_subgraph, install_subgraph = list(heal_graph.topological_order(reverse=True))
-
-    assert len(list(uninstall_subgraph.tasks)) == 2
-    dependent_node_subgraph_uninstall, dependency_node_subgraph_uninstall = \
-        list(uninstall_subgraph.topological_order(reverse=True))
-
-    assert len(list(install_subgraph.tasks)) == 2
-    dependency_node_subgraph_install, dependent_node_subgraph_install = \
-        list(install_subgraph.topological_order(reverse=True))
-
-    dependent_node_uninstall_tasks = \
-        list(dependent_node_subgraph_uninstall.topological_order(reverse=True))
-    assert isinstance(dependency_node_subgraph_uninstall, task.StubTask)
-    dependent_node_install_tasks = \
-        list(dependent_node_subgraph_install.topological_order(reverse=True))
-    assert isinstance(dependency_node_subgraph_install, task.StubTask)
-
-    assert_node_uninstall_operations(dependent_node_uninstall_tasks, with_relationships=True)
-    assert_node_install_operations(dependent_node_install_tasks, with_relationships=True)
-
-
-def test_heal_dependency_node(ctx):
-    heal_graph = task.WorkflowTask(heal, ctx=ctx, node_instance_id='dependency_node_instance')
-    # both subgraphs should contain un\install for both the dependent and the dependency
-    assert len(list(heal_graph.tasks)) == 2
-    uninstall_subgraph, install_subgraph = list(heal_graph.topological_order(reverse=True))
-
-    uninstall_tasks = list(uninstall_subgraph.topological_order(reverse=True))
-    assert len(uninstall_tasks) == 4
-    unlink_source, unlink_target = uninstall_tasks[:2]
-    dependent_node_subgraph_uninstall, dependency_node_subgraph_uninstall = uninstall_tasks[2:]
-
-    install_tasks = list(install_subgraph.topological_order(reverse=True))
-    assert len(install_tasks) == 4
-    dependency_node_subgraph_install, dependent_node_subgraph_install = install_tasks[:2]
-    establish_source, establish_target = install_tasks[2:]
-
-    assert isinstance(dependent_node_subgraph_uninstall, task.StubTask)
-    dependency_node_uninstall_tasks = \
-        list(dependency_node_subgraph_uninstall.topological_order(reverse=True))
-    assert isinstance(dependent_node_subgraph_install, task.StubTask)
-    dependency_node_install_tasks = \
-        list(dependency_node_subgraph_install.topological_order(reverse=True))
-
-    assert unlink_source.name.startswith('aria.interfaces.relationship_lifecycle.unlink')
-    assert unlink_target.name.startswith('aria.interfaces.relationship_lifecycle.unlink')
-    assert_node_uninstall_operations(dependency_node_uninstall_tasks)
-
-    assert_node_install_operations(dependency_node_install_tasks)
-    assert establish_source.name.startswith('aria.interfaces.relationship_lifecycle.establish')
-    assert establish_target.name.startswith('aria.interfaces.relationship_lifecycle.establish')
-
-
-# TODO: add tests for contained in scenario

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/builtin/test_install.py
----------------------------------------------------------------------
diff --git a/tests/workflows/builtin/test_install.py b/tests/workflows/builtin/test_install.py
deleted file mode 100644
index 29212e3..0000000
--- a/tests/workflows/builtin/test_install.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import pytest
-
-from aria.workflows.builtin.install import install
-from aria.workflows.api import task
-
-from . import (assert_node_install_operations,
-               ctx_with_basic_graph)
-
-
-@pytest.fixture
-def ctx():
-    return ctx_with_basic_graph()
-
-
-def test_install(ctx):
-    install_tasks = list(task.WorkflowTask(install, ctx=ctx).topological_order(True))
-
-    assert len(install_tasks) == 2
-    dependency_node_subgraph, dependent_node_subgraph = install_tasks
-    dependent_node_tasks = list(dependent_node_subgraph.topological_order(reverse=True))
-    dependency_node_tasks = list(dependency_node_subgraph.topological_order(reverse=True))
-
-    assert_node_install_operations(dependency_node_tasks)
-    assert_node_install_operations(dependent_node_tasks, with_relationships=True)

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/builtin/test_uninstall.py
----------------------------------------------------------------------
diff --git a/tests/workflows/builtin/test_uninstall.py b/tests/workflows/builtin/test_uninstall.py
deleted file mode 100644
index 2d00673..0000000
--- a/tests/workflows/builtin/test_uninstall.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import pytest
-
-from aria.workflows.api import task
-from aria.workflows.builtin.uninstall import uninstall
-
-from . import (assert_node_uninstall_operations,
-               ctx_with_basic_graph)
-
-
-@pytest.fixture
-def ctx():
-    return ctx_with_basic_graph()
-
-
-def test_uninstall(ctx):
-    uninstall_tasks = list(task.WorkflowTask(uninstall, ctx=ctx).topological_order(True))
-
-    assert len(uninstall_tasks) == 2
-    dependent_node_subgraph, dependency_node_subgraph = uninstall_tasks
-    dependent_node_tasks = list(dependent_node_subgraph.topological_order(reverse=True))
-    dependency_node_tasks = list(dependency_node_subgraph.topological_order(reverse=True))
-
-    assert_node_uninstall_operations(operations=dependency_node_tasks)
-    assert_node_uninstall_operations(operations=dependent_node_tasks, with_relationships=True)

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/core/__init__.py
----------------------------------------------------------------------
diff --git a/tests/workflows/core/__init__.py b/tests/workflows/core/__init__.py
deleted file mode 100644
index ae1e83e..0000000
--- a/tests/workflows/core/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/core/test_engine.py
----------------------------------------------------------------------
diff --git a/tests/workflows/core/test_engine.py b/tests/workflows/core/test_engine.py
deleted file mode 100644
index 9e12c0b..0000000
--- a/tests/workflows/core/test_engine.py
+++ /dev/null
@@ -1,433 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import time
-import threading
-from datetime import datetime
-
-import pytest
-
-import aria
-from aria import (
-    events,
-    workflow,
-    operation,
-    context
-)
-from aria.storage import models
-from aria.workflows import (
-    api,
-    exceptions,
-)
-from aria.workflows.core import engine
-from aria.workflows.executor import thread
-
-
-import tests.storage
-from tests import mock
-
-
-global_test_holder = {}
-
-
-class BaseTest(object):
-
-    @classmethod
-    def _execute(cls, workflow_func, workflow_context, executor):
-        eng = cls._engine(workflow_func=workflow_func,
-                          workflow_context=workflow_context,
-                          executor=executor)
-        eng.execute()
-        return eng
-
-    @staticmethod
-    def _engine(workflow_func, workflow_context, executor):
-        graph = workflow_func(ctx=workflow_context)
-        return engine.Engine(executor=executor,
-                             workflow_context=workflow_context,
-                             tasks_graph=graph)
-
-    @staticmethod
-    def _op(func, ctx,
-            inputs=None,
-            max_attempts=None,
-            retry_interval=None,
-            ignore_failure=None):
-        node_instance = ctx.model.node_instance.get('dependency_node_instance')
-        node_instance.node.operations['aria.interfaces.lifecycle.create'] = {
-            'operation': 'tests.workflows.core.test_engine.{name}'.format(name=func.__name__)
-        }
-        ctx.model.node_instance.store(node_instance)
-        return api.task.OperationTask.node_instance(
-            instance=node_instance,
-            name='aria.interfaces.lifecycle.create',
-            inputs=inputs,
-            max_attempts=max_attempts,
-            retry_interval=retry_interval,
-            ignore_failure=ignore_failure
-        )
-
-    @pytest.fixture(scope='function', autouse=True)
-    def globals_cleanup(self):
-        try:
-            yield
-        finally:
-            global_test_holder.clear()
-
-    @pytest.fixture(scope='function', autouse=True)
-    def signals_registration(self, ):
-        def sent_task_handler(*args, **kwargs):
-            calls = global_test_holder.setdefault('sent_task_signal_calls', 0)
-            global_test_holder['sent_task_signal_calls'] = calls + 1
-
-        def start_workflow_handler(workflow_context, *args, **kwargs):
-            workflow_context.states.append('start')
-
-        def success_workflow_handler(workflow_context, *args, **kwargs):
-            workflow_context.states.append('success')
-
-        def failure_workflow_handler(workflow_context, exception, *args, **kwargs):
-            workflow_context.states.append('failure')
-            workflow_context.exception = exception
-
-        def cancel_workflow_handler(workflow_context, *args, **kwargs):
-            workflow_context.states.append('cancel')
-
-        events.start_workflow_signal.connect(start_workflow_handler)
-        events.on_success_workflow_signal.connect(success_workflow_handler)
-        events.on_failure_workflow_signal.connect(failure_workflow_handler)
-        events.on_cancelled_workflow_signal.connect(cancel_workflow_handler)
-        events.sent_task_signal.connect(sent_task_handler)
-        try:
-            yield
-        finally:
-            events.start_workflow_signal.disconnect(start_workflow_handler)
-            events.on_success_workflow_signal.disconnect(success_workflow_handler)
-            events.on_failure_workflow_signal.disconnect(failure_workflow_handler)
-            events.on_cancelled_workflow_signal.disconnect(cancel_workflow_handler)
-            events.sent_task_signal.disconnect(sent_task_handler)
-
-    @pytest.fixture(scope='function')
-    def executor(self):
-        result = thread.ThreadExecutor()
-        try:
-            yield result
-        finally:
-            result.close()
-
-    @pytest.fixture(scope='function')
-    def workflow_context(self):
-        model_storage = aria.application_model_storage(tests.storage.InMemoryModelDriver())
-        model_storage.setup()
-        blueprint = mock.models.get_blueprint()
-        deployment = mock.models.get_deployment()
-        model_storage.blueprint.store(blueprint)
-        model_storage.deployment.store(deployment)
-        node = mock.models.get_dependency_node()
-        node_instance = mock.models.get_dependency_node_instance(node)
-        model_storage.node.store(node)
-        model_storage.node_instance.store(node_instance)
-        result = context.workflow.WorkflowContext(
-            name='test',
-            model_storage=model_storage,
-            resource_storage=None,
-            deployment_id=deployment.id,
-            workflow_id='name')
-        result.states = []
-        result.exception = None
-        return result
-
-
-class TestEngine(BaseTest):
-
-    def test_empty_graph_execution(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(**_):
-            pass
-        self._execute(workflow_func=mock_workflow,
-                      workflow_context=workflow_context,
-                      executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        assert 'sent_task_signal_calls' not in global_test_holder
-        execution = workflow_context.execution
-        assert execution.started_at <= execution.ended_at <= datetime.utcnow()
-        assert execution.error is None
-        assert execution.status == models.Execution.TERMINATED
-
-    def test_single_task_successful_execution(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            graph.add_tasks(self._op(mock_success_task, ctx))
-        self._execute(
-            workflow_func=mock_workflow,
-            workflow_context=workflow_context,
-            executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        assert global_test_holder.get('sent_task_signal_calls') == 1
-
-    def test_single_task_failed_execution(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            graph.add_tasks(self._op(mock_failed_task, ctx))
-        with pytest.raises(exceptions.ExecutorException):
-            self._execute(
-                workflow_func=mock_workflow,
-                workflow_context=workflow_context,
-                executor=executor)
-        assert workflow_context.states == ['start', 'failure']
-        assert isinstance(workflow_context.exception, exceptions.ExecutorException)
-        assert global_test_holder.get('sent_task_signal_calls') == 1
-        execution = workflow_context.execution
-        assert execution.started_at <= execution.ended_at <= datetime.utcnow()
-        assert execution.error is not None
-        assert execution.status == models.Execution.FAILED
-
-    def test_two_tasks_execution_order(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            op1 = self._op(mock_ordered_task, ctx, inputs={'counter': 1})
-            op2 = self._op(mock_ordered_task, ctx, inputs={'counter': 2})
-            graph.sequence(op1, op2)
-        self._execute(
-            workflow_func=mock_workflow,
-            workflow_context=workflow_context,
-            executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        assert global_test_holder.get('invocations') == [1, 2]
-        assert global_test_holder.get('sent_task_signal_calls') == 2
-
-    def test_stub_and_subworkflow_execution(self, workflow_context, executor):
-        @workflow
-        def sub_workflow(ctx, graph):
-            op1 = self._op(mock_ordered_task, ctx, inputs={'counter': 1})
-            op2 = api.task.StubTask()
-            op3 = self._op(mock_ordered_task, ctx, inputs={'counter': 2})
-            graph.sequence(op1, op2, op3)
-
-        @workflow
-        def mock_workflow(ctx, graph):
-            graph.add_tasks(api.task.WorkflowTask(sub_workflow, ctx=ctx))
-        self._execute(workflow_func=mock_workflow,
-                      workflow_context=workflow_context,
-                      executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        assert global_test_holder.get('invocations') == [1, 2]
-        assert global_test_holder.get('sent_task_signal_calls') == 2
-
-
-class TestCancel(BaseTest):
-
-    def test_cancel_started_execution(self, workflow_context, executor):
-        number_of_tasks = 100
-
-        @workflow
-        def mock_workflow(ctx, graph):
-            return graph.sequence(*(self._op(mock_sleep_task, ctx, inputs={'seconds': 0.1})
-                                    for _ in range(number_of_tasks)))
-        eng = self._engine(workflow_func=mock_workflow,
-                           workflow_context=workflow_context,
-                           executor=executor)
-        t = threading.Thread(target=eng.execute)
-        t.start()
-        time.sleep(1)
-        eng.cancel_execution()
-        t.join(timeout=30)
-        assert workflow_context.states == ['start', 'cancel']
-        assert workflow_context.exception is None
-        invocations = global_test_holder.get('invocations', [])
-        assert 0 < len(invocations) < number_of_tasks
-        execution = workflow_context.execution
-        assert execution.started_at <= execution.ended_at <= datetime.utcnow()
-        assert execution.error is None
-        assert execution.status == models.Execution.CANCELLED
-
-    def test_cancel_pending_execution(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(graph, **_):
-            return graph
-        eng = self._engine(workflow_func=mock_workflow,
-                           workflow_context=workflow_context,
-                           executor=executor)
-        eng.cancel_execution()
-        execution = workflow_context.execution
-        assert execution.status == models.Execution.CANCELLED
-
-
-class TestRetries(BaseTest):
-
-    def test_two_max_attempts_and_success_on_retry(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            op = self._op(mock_conditional_failure_task, ctx,
-                          inputs={'failure_count': 1},
-                          max_attempts=2)
-            graph.add_tasks(op)
-        self._execute(
-            workflow_func=mock_workflow,
-            workflow_context=workflow_context,
-            executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        assert len(global_test_holder.get('invocations', [])) == 2
-        assert global_test_holder.get('sent_task_signal_calls') == 2
-
-    def test_two_max_attempts_and_failure_on_retry(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            op = self._op(mock_conditional_failure_task, ctx,
-                          inputs={'failure_count': 2},
-                          max_attempts=2)
-            graph.add_tasks(op)
-        with pytest.raises(exceptions.ExecutorException):
-            self._execute(
-                workflow_func=mock_workflow,
-                workflow_context=workflow_context,
-                executor=executor)
-        assert workflow_context.states == ['start', 'failure']
-        assert isinstance(workflow_context.exception, exceptions.ExecutorException)
-        assert len(global_test_holder.get('invocations', [])) == 2
-        assert global_test_holder.get('sent_task_signal_calls') == 2
-
-    def test_three_max_attempts_and_success_on_first_retry(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            op = self._op(mock_conditional_failure_task, ctx,
-                          inputs={'failure_count': 1},
-                          max_attempts=3)
-            graph.add_tasks(op)
-        self._execute(
-            workflow_func=mock_workflow,
-            workflow_context=workflow_context,
-            executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        assert len(global_test_holder.get('invocations', [])) == 2
-        assert global_test_holder.get('sent_task_signal_calls') == 2
-
-    def test_three_max_attempts_and_success_on_second_retry(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            op = self._op(mock_conditional_failure_task, ctx,
-                          inputs={'failure_count': 2},
-                          max_attempts=3)
-            graph.add_tasks(op)
-        self._execute(
-            workflow_func=mock_workflow,
-            workflow_context=workflow_context,
-            executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        assert len(global_test_holder.get('invocations', [])) == 3
-        assert global_test_holder.get('sent_task_signal_calls') == 3
-
-    def test_infinite_retries(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            op = self._op(mock_conditional_failure_task, ctx,
-                          inputs={'failure_count': 1},
-                          max_attempts=-1)
-            graph.add_tasks(op)
-        self._execute(
-            workflow_func=mock_workflow,
-            workflow_context=workflow_context,
-            executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        assert len(global_test_holder.get('invocations', [])) == 2
-        assert global_test_holder.get('sent_task_signal_calls') == 2
-
-    def test_retry_interval_float(self, workflow_context, executor):
-        self._test_retry_interval(retry_interval=0.3,
-                                  workflow_context=workflow_context,
-                                  executor=executor)
-
-    def test_retry_interval_int(self, workflow_context, executor):
-        self._test_retry_interval(retry_interval=1,
-                                  workflow_context=workflow_context,
-                                  executor=executor)
-
-    def _test_retry_interval(self, retry_interval, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            op = self._op(mock_conditional_failure_task, ctx,
-                          inputs={'failure_count': 1},
-                          max_attempts=2,
-                          retry_interval=retry_interval)
-            graph.add_tasks(op)
-        self._execute(
-            workflow_func=mock_workflow,
-            workflow_context=workflow_context,
-            executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        invocations = global_test_holder.get('invocations', [])
-        assert len(invocations) == 2
-        invocation1, invocation2 = invocations
-        assert invocation2 - invocation1 >= retry_interval
-        assert global_test_holder.get('sent_task_signal_calls') == 2
-
-    def test_ignore_failure(self, workflow_context, executor):
-        @workflow
-        def mock_workflow(ctx, graph):
-            op = self._op(mock_conditional_failure_task, ctx,
-                          ignore_failure=True,
-                          inputs={'failure_count': 100},
-                          max_attempts=100)
-            graph.add_tasks(op)
-        self._execute(
-            workflow_func=mock_workflow,
-            workflow_context=workflow_context,
-            executor=executor)
-        assert workflow_context.states == ['start', 'success']
-        assert workflow_context.exception is None
-        invocations = global_test_holder.get('invocations', [])
-        assert len(invocations) == 1
-        assert global_test_holder.get('sent_task_signal_calls') == 1
-
-
-@operation
-def mock_success_task(**_):
-    pass
-
-
-@operation
-def mock_failed_task(**_):
-    raise RuntimeError
-
-
-@operation
-def mock_ordered_task(counter, **_):
-    invocations = global_test_holder.setdefault('invocations', [])
-    invocations.append(counter)
-
-
-@operation
-def mock_conditional_failure_task(failure_count, **_):
-    invocations = global_test_holder.setdefault('invocations', [])
-    try:
-        if len(invocations) < failure_count:
-            raise RuntimeError
-    finally:
-        invocations.append(time.time())
-
-
-def mock_sleep_task(seconds, **_):
-    invocations = global_test_holder.setdefault('invocations', [])
-    invocations.append(time.time())
-    time.sleep(seconds)

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/core/test_task.py
----------------------------------------------------------------------
diff --git a/tests/workflows/core/test_task.py b/tests/workflows/core/test_task.py
deleted file mode 100644
index 56e49c6..0000000
--- a/tests/workflows/core/test_task.py
+++ /dev/null
@@ -1,113 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from datetime import (
-    datetime,
-    timedelta
-)
-
-import pytest
-
-from aria.context import workflow as workflow_context
-from aria.workflows import (
-    api,
-    core,
-    exceptions,
-)
-
-from ... import mock
-
-
-@pytest.fixture
-def ctx():
-    simple_context = mock.context.simple()
-
-    blueprint = mock.models.get_blueprint()
-    deployment = mock.models.get_deployment()
-    node = mock.models.get_dependency_node()
-    node_instance = mock.models.get_dependency_node_instance(node)
-    execution = mock.models.get_execution()
-
-    simple_context.model.blueprint.store(blueprint)
-    simple_context.model.deployment.store(deployment)
-    simple_context.model.node.store(node)
-    simple_context.model.node_instance.store(node_instance)
-    simple_context.model.execution.store(execution)
-
-    return simple_context
-
-
-class TestOperationTask(object):
-
-    def _create_operation_task(self, ctx, node_instance):
-        with workflow_context.current.push(ctx):
-            api_task = api.task.OperationTask.node_instance(
-                instance=node_instance,
-                name='aria.interfaces.lifecycle.create',
-            )
-
-            core_task = core.task.OperationTask(api_task=api_task)
-
-        return api_task, core_task
-
-    def test_operation_task_creation(self, ctx):
-        node_instance = ctx.model.node_instance.get(mock.models.DEPENDENCY_NODE_INSTANCE_ID)
-        api_task, core_task = self._create_operation_task(ctx, node_instance)
-        storage_task = ctx.model.task.get(core_task.id)
-
-        assert core_task.model_task == storage_task
-        assert core_task.name == api_task.name
-        assert core_task.operation_mapping == api_task.operation_mapping
-        assert core_task.actor == api_task.actor == node_instance
-        assert core_task.inputs == api_task.inputs == storage_task.inputs
-
-    def test_operation_task_edit_locked_attribute(self, ctx):
-        node_instance = ctx.model.node_instance.get(mock.models.DEPENDENCY_NODE_INSTANCE_ID)
-
-        _, core_task = self._create_operation_task(ctx, node_instance)
-        now = datetime.utcnow()
-        with pytest.raises(exceptions.TaskException):
-            core_task.status = core_task.STARTED
-        with pytest.raises(exceptions.TaskException):
-            core_task.started_at = now
-        with pytest.raises(exceptions.TaskException):
-            core_task.ended_at = now
-        with pytest.raises(exceptions.TaskException):
-            core_task.retry_count = 2
-        with pytest.raises(exceptions.TaskException):
-            core_task.due_at = now
-
-    def test_operation_task_edit_attributes(self, ctx):
-        node_instance = ctx.model.node_instance.get(mock.models.DEPENDENCY_NODE_INSTANCE_ID)
-
-        _, core_task = self._create_operation_task(ctx, node_instance)
-        future_time = datetime.utcnow() + timedelta(seconds=3)
-
-        with core_task._update():
-            core_task.status = core_task.STARTED
-            core_task.started_at = future_time
-            core_task.ended_at = future_time
-            core_task.retry_count = 2
-            core_task.eta = future_time
-            assert core_task.status != core_task.STARTED
-            assert core_task.started_at != future_time
-            assert core_task.ended_at != future_time
-            assert core_task.retry_count != 2
-            assert core_task.due_at != future_time
-
-        assert core_task.status == core_task.STARTED
-        assert core_task.started_at == future_time
-        assert core_task.ended_at == future_time
-        assert core_task.retry_count == 2
-        assert core_task.eta == future_time

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/core/test_task_graph_into_exececution_graph.py
----------------------------------------------------------------------
diff --git a/tests/workflows/core/test_task_graph_into_exececution_graph.py b/tests/workflows/core/test_task_graph_into_exececution_graph.py
deleted file mode 100644
index 2e7c7df..0000000
--- a/tests/workflows/core/test_task_graph_into_exececution_graph.py
+++ /dev/null
@@ -1,105 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from networkx import topological_sort, DiGraph
-
-from aria import context
-from aria.workflows import api, core
-
-from ... import mock
-
-
-def test_task_graph_into_execution_graph():
-    operation_name = 'aria.interfaces.lifecycle.create'
-    task_context = mock.context.simple()
-    node = mock.models.get_dependency_node()
-    node_instance = mock.models.get_dependency_node_instance()
-    deployment = mock.models.get_deployment()
-    execution = mock.models.get_execution()
-    task_context.model.node.store(node)
-    task_context.model.node_instance.store(node_instance)
-    task_context.model.deployment.store(deployment)
-    task_context.model.execution.store(execution)
-
-    def sub_workflow(name, **_):
-        return api.task_graph.TaskGraph(name)
-
-    with context.workflow.current.push(task_context):
-        test_task_graph = api.task.WorkflowTask(sub_workflow, name='test_task_graph')
-        simple_before_task = api.task.OperationTask.node_instance(instance=node_instance,
-                                                                  name=operation_name)
-        simple_after_task = api.task.OperationTask.node_instance(instance=node_instance,
-                                                                 name=operation_name)
-
-        inner_task_graph = api.task.WorkflowTask(sub_workflow, name='test_inner_task_graph')
-        inner_task = api.task.OperationTask.node_instance(instance=node_instance,
-                                                          name=operation_name)
-        inner_task_graph.add_tasks(inner_task)
-
-    test_task_graph.add_tasks(simple_before_task)
-    test_task_graph.add_tasks(simple_after_task)
-    test_task_graph.add_tasks(inner_task_graph)
-    test_task_graph.add_dependency(inner_task_graph, simple_before_task)
-    test_task_graph.add_dependency(simple_after_task, inner_task_graph)
-
-    # Direct check
-    execution_graph = DiGraph()
-    core.translation.build_execution_graph(task_graph=test_task_graph,
-                                           execution_graph=execution_graph)
-    execution_tasks = topological_sort(execution_graph)
-
-    assert len(execution_tasks) == 7
-
-    expected_tasks_names = [
-        '{0}-Start'.format(test_task_graph.id),
-        simple_before_task.id,
-        '{0}-Start'.format(inner_task_graph.id),
-        inner_task.id,
-        '{0}-End'.format(inner_task_graph.id),
-        simple_after_task.id,
-        '{0}-End'.format(test_task_graph.id)
-    ]
-
-    assert expected_tasks_names == execution_tasks
-
-    assert isinstance(_get_task_by_name(execution_tasks[0], execution_graph),
-                      core.task.StartWorkflowTask)
-
-    _assert_execution_is_api_task(_get_task_by_name(execution_tasks[1], execution_graph),
-                                  simple_before_task)
-    assert isinstance(_get_task_by_name(execution_tasks[2], execution_graph),
-                      core.task.StartSubWorkflowTask)
-
-    _assert_execution_is_api_task(_get_task_by_name(execution_tasks[3], execution_graph),
-                                  inner_task)
-    assert isinstance(_get_task_by_name(execution_tasks[4], execution_graph),
-                      core.task.EndSubWorkflowTask)
-
-    _assert_execution_is_api_task(_get_task_by_name(execution_tasks[5], execution_graph),
-                                  simple_after_task)
-    assert isinstance(_get_task_by_name(execution_tasks[6], execution_graph),
-                      core.task.EndWorkflowTask)
-
-
-def _assert_execution_is_api_task(execution_task, api_task):
-    assert execution_task.id == api_task.id
-    assert execution_task.name == api_task.name
-    assert execution_task.operation_mapping == api_task.operation_mapping
-    assert execution_task.actor == api_task.actor
-    assert execution_task.inputs == api_task.inputs
-
-
-def _get_task_by_name(task_name, graph):
-    return graph.node[task_name]['task']

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/17510b02/tests/workflows/executor/__init__.py
----------------------------------------------------------------------
diff --git a/tests/workflows/executor/__init__.py b/tests/workflows/executor/__init__.py
deleted file mode 100644
index ae1e83e..0000000
--- a/tests/workflows/executor/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.



Mime
View raw message