tests/mock/models.py

# 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

from aria.modeling import models
from aria.orchestrator import decorators
from aria.orchestrator.workflows.builtin.workflows import (
    NORMATIVE_STANDARD_INTERFACE,
    NORMATIVE_CREATE,
    NORMATIVE_START,
    NORMATIVE_STOP,
    NORMATIVE_DELETE,
    NORMATIVE_CONFIGURE,

    NORMATIVE_CONFIGURE_INTERFACE,
    NORMATIVE_PRE_CONFIGURE_SOURCE,
    NORMATIVE_PRE_CONFIGURE_TARGET,
    NORMATIVE_POST_CONFIGURE_SOURCE,
    NORMATIVE_POST_CONFIGURE_TARGET,

    NORMATIVE_ADD_SOURCE,
    NORMATIVE_ADD_TARGET,
    NORMATIVE_REMOVE_TARGET,
    NORMATIVE_REMOVE_SOURCE
)

SERVICE_TEMPLATE_NAME = 'test_service_template'
SERVICE_NAME = 'test_service1'
NODE_TEMPLATE_NAME = 'test_node_template'
NODE_NAME = 'test_node1'
WORKFLOW_NAME = 'test_workflow'
TASK_RETRY_INTERVAL = 1
TASK_MAX_ATTEMPTS = 1

DEPENDENCY_NODE_TEMPLATE_NAME = 'dependency_node_template'
DEPENDENCY_NODE_NAME = 'dependency_node'
DEPENDENT_NODE_TEMPLATE_NAME = 'dependent_node_template'
DEPENDENT_NODE_NAME = 'dependent_node'


def create_service_template(name=SERVICE_TEMPLATE_NAME, description=None, inputs=None):
    now = datetime.now()
    inputs = inputs or {}
    return models.ServiceTemplate(
        name=name,
        description=description,
        inputs=inputs,
        created_at=now,
        updated_at=now,
        main_file_name='main_file_name',
        node_types=models.Type(variant='node', name='test_node_type'),
        group_types=models.Type(variant='group', name='test_group_type'),
        policy_types=models.Type(variant='policy', name='test_policy_type'),
        relationship_types=models.Type(variant='relationship', name='test_relationship_type'),
        capability_types=models.Type(variant='capability', name='test_capability_type'),
        artifact_types=models.Type(variant='artifact', name='test_artifact_type'),
        interface_types=models.Type(variant='interface', name='test_interface_type')
    )


def create_service(service_template, name=SERVICE_NAME, inputs=None):
    now = datetime.utcnow()
    inputs = inputs or {}
    return models.Service(
        name=name,
        inputs=inputs,
        service_template=service_template,
        description='',
        created_at=now,
        updated_at=now,
    )


def create_service_with_dependencies(include_execution=False,
                                     include_input=False,
                                     include_output=False,
                                     include_node=False):
    service_template = create_service_template()
    service = create_service(service_template=service_template)
    if include_execution:
        execution = create_execution(service=service, status=models.Execution.STARTED)
        service.executions = [execution]
        execution.id = '1'
    if include_input:
        input = create_input(name='input1', value='value1')
        service.inputs = {'input1': input}
    if include_output:
        output = create_output(name='output1', value='value1')
        service.outputs = {'output1': output}
    if include_node:
        node_template = create_node_template(service_template=service_template)
        node = create_node(node_template, service, state=models.Node.STARTED)
        node.id = '1'
    return service


def create_node_template_with_dependencies(include_node=False, include_property=False):
    service_template = create_service_template()
    node_template = create_node_template(service_template=service_template)
    if include_node:
        service = create_service(service_template=service_template)
        create_node(dependency_node_template=node_template, service=service)
    if include_property:
        node_template.properties = {'prop1': create_property(name='prop1', value='value1')}
    return node_template


def create_node_with_dependencies(include_attribute=False):

    node_template = create_node_template_with_dependencies()
    node_template.service_template.services[0] = create_service(node_template.service_template)
    node = create_node(node_template, node_template.service_template.services[0])
    if include_attribute:
        node.attributes['attribute1'] = models.Attribute.wrap('attribute1', 'value1')               # pylint: disable=unsubscriptable-object
    return node


def create_node_template(service_template,
                         name=NODE_TEMPLATE_NAME,
                         type=models.Type(variant='node', name='test_node_type'),
                         capability_templates=None,
                         requirement_templates=None,
                         interface_templates=None):
    capability_templates = capability_templates or {}
    requirement_templates = requirement_templates or []
    interface_templates = interface_templates or {}
    node_template = models.NodeTemplate(
        name=name,
        type=type,
        capability_templates=capability_templates,
        requirement_templates=requirement_templates,
        interface_templates=interface_templates,
        service_template=service_template)

    service_template.node_templates[node_template.name] = node_template
    return node_template


def create_dependency_node_template(service_template, name=DEPENDENCY_NODE_TEMPLATE_NAME):
    node_type = service_template.node_types.get_descendant('test_node_type')
    capability_type = service_template.capability_types.get_descendant('test_capability_type')

    capability_template = models.CapabilityTemplate(
        name='capability',
        type=capability_type
    )
    return create_node_template(
        service_template=service_template,
        name=name,
        type=node_type,
        capability_templates=_dictify(capability_template)
    )


def create_dependent_node_template(
        service_template, dependency_node_template, name=DEPENDENT_NODE_TEMPLATE_NAME):
    the_type = service_template.node_types.get_descendant('test_node_type')

    requirement_template = models.RequirementTemplate(
        name='requirement',
        target_node_template=dependency_node_template
    )
    return create_node_template(
        service_template=service_template,
        name=name,
        type=the_type,
        interface_templates=_dictify(get_standard_interface_template(service_template)),
        requirement_templates=[requirement_template],
    )


def create_node(dependency_node_template, service, name=NODE_NAME, state=models.Node.INITIAL):
    node = models.Node(
        name=name,
        type=dependency_node_template.type,
        version=None,
        node_template=dependency_node_template,
        state=state,
        service=service,
        interfaces=get_standard_interface(service),
    )
    service.nodes[node.name] = node
    return node


def create_relationship(source, target):
    return models.Relationship(
        source_node=source,
        target_node=target,
        interfaces=get_configure_interfaces(service=source.service),
    )


def create_interface_template(service_template, interface_name, operation_name,
                              operation_kwargs=None, interface_kwargs=None):
    the_type = service_template.interface_types.get_descendant('test_interface_type')
    operation_template = models.OperationTemplate(
        name=operation_name,
        **(operation_kwargs or {})
    )
    return models.InterfaceTemplate(
        type=the_type,
        operation_templates=_dictify(operation_template),
        name=interface_name,
        **(interface_kwargs or {})
    )


def create_operation(operation_name, operation_kwargs=None):
    if operation_kwargs and operation_kwargs.get('arguments'):
        operation_kwargs['arguments'] = dict(
            (argument_name, models.Argument.wrap(argument_name, argument_value))
            for argument_name, argument_value in operation_kwargs['arguments'].iteritems()
            if argument_value is not None)

    return models.Operation(
        name=operation_name,
        **(operation_kwargs or {})
    )


def create_interface(service, interface_name, operation_name, operation_kwargs=None,
                     interface_kwargs=None):
    the_type = service.service_template.interface_types.get_descendant('test_interface_type')
    operation = create_operation(operation_name, operation_kwargs)

    return models.Interface(
        type=the_type,
        operations=_dictify(operation),
        name=interface_name,
        **(interface_kwargs or {})
    )


def create_execution(service, status=models.Execution.PENDING):
    return models.Execution(
        service=service,
        status=status,
        workflow_name=WORKFLOW_NAME,
        created_at=datetime.utcnow(),
        started_at=datetime.utcnow(),
        inputs={}
    )


def create_plugin(name='test_plugin', package_version='0.1'):
    return models.Plugin(
        name=name,
        archive_name='archive_name',
        distribution='distribution',
        distribution_release='dist_release',
        distribution_version='dist_version',
        package_name='package',
        package_source='source',
        package_version=package_version,
        supported_platform='any',
        supported_py_versions=['python27'],
        uploaded_at=datetime.now(),
        wheels=[],
    )


def create_plugin_specification(name='test_plugin', version='0.1'):
    return models.PluginSpecification(
        name=name,
        version=version
    )


def _create_parameter(name, value, model_cls):
    return model_cls.wrap(name, value)


def create_property(name, value):
    return _create_parameter(name, value, model_cls=models.Property)


def create_input(name, value):
    return _create_parameter(name, value, model_cls=models.Input)


def create_output(name, value):
    return _create_parameter(name, value, model_cls=models.Output)


def _dictify(item):
    return dict(((item.name, item),))


def get_standard_interface_template(service_template):
    the_type = service_template.interface_types.get_descendant('test_interface_type')

    op_templates = dict(
        (op_name, models.OperationTemplate(
            name=op_name, implementation='{0}.{1}'.format(__file__, mock_operation.__name__)))
        for op_name in (NORMATIVE_CREATE, NORMATIVE_CONFIGURE, NORMATIVE_START,
                        NORMATIVE_STOP, NORMATIVE_DELETE)
    )
    return models.InterfaceTemplate(name=NORMATIVE_STANDARD_INTERFACE,
                                    operation_templates=op_templates,
                                    type=the_type)


def get_standard_interface(service):
    the_type = service.service_template.interface_types.get_descendant('test_interface_type')

    ops = dict(
        (op_name, models.Operation(
            name=op_name, implementation='{0}.{1}'.format(__file__, mock_operation.__name__)))
        for op_name in (NORMATIVE_CREATE, NORMATIVE_CONFIGURE, NORMATIVE_START,
                        NORMATIVE_STOP, NORMATIVE_DELETE)
    )
    return {
        NORMATIVE_STANDARD_INTERFACE:
            models.Interface(name=NORMATIVE_STANDARD_INTERFACE, operations=ops, type=the_type)
    }


def get_configure_interfaces(service):
    the_type = service.service_template.interface_types.get_descendant('test_interface_type')

    operations = dict(
        (op_name, models.Operation(
            name=op_name, implementation='{0}.{1}'.format(__file__, mock_operation.__name__)))
        for op_name in (NORMATIVE_PRE_CONFIGURE_SOURCE,
                        NORMATIVE_POST_CONFIGURE_SOURCE,
                        NORMATIVE_ADD_SOURCE,
                        NORMATIVE_REMOVE_SOURCE,

                        NORMATIVE_PRE_CONFIGURE_TARGET,
                        NORMATIVE_POST_CONFIGURE_TARGET,
                        NORMATIVE_ADD_TARGET,
                        NORMATIVE_REMOVE_TARGET)
    )
    interface = {
        NORMATIVE_CONFIGURE_INTERFACE: models.Interface(
            name=NORMATIVE_CONFIGURE_INTERFACE, operations=operations, type=the_type)
    }

    return interface


@decorators.operation
def mock_operation(*args, **kwargs):
    pass