created new module and linting
Project: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/commit/0b1a306f Tree: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/tree/0b1a306f Diff: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/diff/0b1a306f Branch: refs/heads/ARIA-258-Convert-runtime-properties-to-attributes Commit: 0b1a306f6905fbe838e96108f65d47cf075efdbb Parents: 4e85105 Author: max-orlov <ma...@gigaspaces.com> Authored: Mon May 22 17:52:02 2017 +0300 Committer: max-orlov <ma...@gigaspaces.com> Committed: Mon May 22 17:52:02 2017 +0300 ---------------------------------------------------------------------- aria/orchestrator/context/common.py | 144 ++++++----- .../context/test_attribute_suggaring.py | 253 +++++++++++++++++++ tests/orchestrator/context/test_operation.py | 236 ----------------- 3 files changed, 331 insertions(+), 302 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/0b1a306f/aria/orchestrator/context/common.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/context/common.py b/aria/orchestrator/context/common.py index a5c01fa..8b83883 100644 --- a/aria/orchestrator/context/common.py +++ b/aria/orchestrator/context/common.py @@ -16,9 +16,7 @@ """ A common context for both workflow and operation """ -import copy import logging -import collections from contextlib import contextmanager from functools import partial @@ -219,41 +217,38 @@ class _InstrumentedCollection(object): self._is_top_level = is_top_level self._load(seq, **kwargs) + @property + def _raw(self): + raise NotImplementedError + def _load(self, seq, **kwargs): """ Instantiates the object from existing seq. - - :param seq: the original sequence to load from - :return: - """ - raise NotImplementedError - def _set_field(self, collection, key, value): - """ - enables updating the current change in the ancestors - :param collection: the collection to change - :param key: the key for the specific field - :param value: the new value - :return: + :param seq: the original sequence to load from + :return: """ raise NotImplementedError def _set(self, key, value): """ set the changes for the current object (not in the db) - - :param key: - :param value: - :return: + + :param key: + :param value: + :return: """ raise NotImplementedError + def _del(self, collection, key): + raise NotImplementedError + def _instrument(self, key, value): """ Instruments any collection to track changes (and ease of access) - :param key: - :param value: - :return: + :param key: + :param value: + :return: """ if isinstance(value, _InstrumentedCollection): return value @@ -268,9 +263,9 @@ class _InstrumentedCollection(object): def _raw_value(self, value): """ - Get the raw value. - :param value: - :return: + Get the raw value. + :param value: + :return: """ if self._is_top_level and isinstance(value, self._item_cls): return value.value @@ -279,9 +274,9 @@ class _InstrumentedCollection(object): def _encapsulate_value(self, key, value): """ Create a new item cls if needed. - :param key: - :param value: - :return: + :param key: + :param value: + :return: """ if isinstance(value, self._item_cls): return value @@ -290,30 +285,53 @@ class _InstrumentedCollection(object): def __setitem__(self, key, value): """ - Update the values in both the local and the db locations. - :param key: - :param value: - :return: + Update the values in both the local and the db locations. + :param key: + :param value: + :return: """ self._set(key, value) - mapi = getattr(self._model, self._item_cls.__modelname__) if self._is_top_level: - field = getattr(self._parent, self._field_name) # We are at the top level - if key in field: - # Is this a existing field - value = self._set_field(field, key, value) - else: - value = self._set_field(field, key, self._encapsulate_value(key, value)) + field = getattr(self._parent, self._field_name) + mapi = getattr(self._model, self._item_cls.__modelname__) + value = self._set_field(field, + key, + value if key in field else self._encapsulate_value(key, value)) + mapi.update(value) else: # We are not at the top level - value = self._set_field(self._parent, self._field_name, self) + self._set_field(self._parent, self._field_name, self) + + def _set_field(self, collection, key, value): + """ + enables updating the current change in the ancestors + :param collection: the collection to change + :param key: the key for the specific field + :param value: the new value + :return: + """ + if isinstance(value, _InstrumentedCollection): + value = value._raw + if key in collection and isinstance(collection[key], self._item_cls): + if isinstance(collection[key], self.PYTHON_TYPE): + self._del(collection, key) + collection[key].value = value + else: + collection[key] = value + return collection[key] + + def __copy__(self): + return self._raw - mapi.update(value) + def __deepcopy__(self, *args, **kwargs): + return self._raw class _InstrumentedDict(_InstrumentedCollection, dict): + PYTHON_TYPE = dict + def _load(self, dict_=None, **kwargs): dict.__init__( self, @@ -342,17 +360,18 @@ class _InstrumentedDict(_InstrumentedCollection, dict): def _set(self, key, value): dict.__setitem__(self, key, self._raw_value(value)) - def _set_field(self, collection, key, value): - if key in collection and isinstance(collection[key], self._item_cls): - if isinstance(collection[key], dict): - collection[key].clear() - collection[key].value = value - else: - collection[key] = value - return collection[key] + @property + def _raw(self): + return dict(self) + + def _del(self, collection, key): + collection[key].clear() class _InstrumentedList(_InstrumentedCollection, list): + + PYTHON_TYPE = list + def _load(self, list_=None, **kwargs): list.__init__(self, list(item for item in list_ or [])) @@ -373,14 +392,12 @@ class _InstrumentedList(_InstrumentedCollection, list): def _set(self, key, value): list.__setitem__(self, key, value) - def _set_field(self, collection, key, value): - if key in collection and isinstance(collection[key], self._item_cls): - if isinstance(collection[key], list): - del collection[key] - collection[key].value = value - else: - collection[key] = value - return collection[key] + def _del(self, collection, key): + del collection[key] + + @property + def _raw(self): + return list(self) class InstrumentCollection(object): @@ -409,15 +426,10 @@ class InstrumentCollection(object): setattr(self, '_{0}'.format(self._field_name), field) # set instrumented value - setattr( - self, - self._field_name, - _InstrumentedDict( - func_self.model, - self._actor, - field_name=self._field_name, - item_cls=modeling.models.Parameter, - seq=field) - ) + setattr(self, self._field_name, _InstrumentedDict(func_self.model, + self._actor, + self._field_name, + modeling.models.Parameter, + field)) return self return _wrapper http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/0b1a306f/tests/orchestrator/context/test_attribute_suggaring.py ---------------------------------------------------------------------- diff --git a/tests/orchestrator/context/test_attribute_suggaring.py b/tests/orchestrator/context/test_attribute_suggaring.py new file mode 100644 index 0000000..7418d65 --- /dev/null +++ b/tests/orchestrator/context/test_attribute_suggaring.py @@ -0,0 +1,253 @@ +# 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.modeling.models import Parameter +from aria.orchestrator.context import common + + +class MockActor(object): + def __init__(self): + self.dict_ = {} + self.list_ = [] + + +class MockModel(object): + + def __init__(self): + self.parameter = type('MockModel', (object, ), {'model_cls': Parameter, + 'put': lambda *args, **kwargs: None, + 'update': lambda *args, **kwargs: None})() + + +class ContextSugaring(object): + + @pytest.fixture + def actor(self): + return MockActor() + + @pytest.fixture + def model(self): + return MockModel() + + @pytest.fixture + def dict_(self, actor, model): + return common._InstrumentedDict(model, actor, 'dict_', item_cls=Parameter) + + @pytest.fixture + def list_(self, actor, model): + return common._InstrumentedList(model, actor, field_name='list_', item_cls=Parameter) + + +class TestDict(ContextSugaring): + + def test_keys(self, actor, dict_): + dict_.update( + { + 'key1': Parameter.wrap('key1', 'value1'), + 'key2': Parameter.wrap('key2', 'value2') + } + ) + assert sorted(dict_.keys()) == sorted(['key1', 'key2']) == sorted(actor.dict_.keys()) + + def test_values(self, actor, dict_): + dict_.update({ + 'key1': Parameter.wrap('key1', 'value1'), + 'key2': Parameter.wrap('key1', 'value2') + }) + assert (sorted(dict_.values()) == + sorted(['value1', 'value2']) == + sorted(v.value for v in actor.dict_.values())) + + def test_items(self, dict_): + dict_.update({ + 'key1': Parameter.wrap('key1', 'value1'), + 'key2': Parameter.wrap('key1', 'value2') + }) + assert sorted(dict_.items()) == sorted([('key1', 'value1'), ('key2', 'value2')]) + + def test_iter(self, actor, dict_): + dict_.update({ + 'key1': Parameter.wrap('key1', 'value1'), + 'key2': Parameter.wrap('key1', 'value2') + }) + assert sorted(list(dict_)) == sorted(['key1', 'key2']) == sorted(actor.dict_.keys()) + + def test_bool(self, dict_): + assert not dict_ + dict_.update({ + 'key1': Parameter.wrap('key1', 'value1'), + 'key2': Parameter.wrap('key1', 'value2') + }) + assert dict_ + + def test_set_item(self, actor, dict_): + dict_['key1'] = Parameter.wrap('key1', 'value1') + assert dict_['key1'] == 'value1' == actor.dict_['key1'].value + assert isinstance(actor.dict_['key1'], Parameter) + + def test_nested(self, actor, dict_): + dict_['key'] = {} + assert isinstance(actor.dict_['key'], Parameter) + assert dict_['key'] == actor.dict_['key'].value == {} + + dict_['key']['inner_key'] = 'value' + + assert len(dict_) == 1 + assert 'inner_key' in dict_['key'] + assert dict_['key']['inner_key'] == 'value' + assert dict_['key'].keys() == ['inner_key'] + assert dict_['key'].values() == ['value'] + assert dict_['key'].items() == [('inner_key', 'value')] + assert isinstance(actor.dict_['key'], Parameter) + assert isinstance(dict_['key'], common._InstrumentedDict) + + dict_['key'].update({'updated_key': 'updated_value'}) + assert len(dict_) == 1 + assert 'updated_key' in dict_['key'] + assert dict_['key']['updated_key'] == 'updated_value' + assert sorted(dict_['key'].keys()) == sorted(['inner_key', 'updated_key']) + assert sorted(dict_['key'].values()) == sorted(['value', 'updated_value']) + assert sorted(dict_['key'].items()) == sorted([('inner_key', 'value'), + ('updated_key', 'updated_value')]) + assert isinstance(actor.dict_['key'], Parameter) + assert isinstance(dict_['key'], common._InstrumentedDict) + + dict_.update({'key': 'override_value'}) + assert len(dict_) == 1 + assert 'key' in dict_ + assert dict_['key'] == 'override_value' + assert len(actor.dict_) == 1 + assert isinstance(actor.dict_['key'], Parameter) + assert actor.dict_['key'].value == 'override_value' + + def test_get_item(self, actor, dict_): + dict_['key1'] = Parameter.wrap('key1', 'value1') + assert isinstance(actor.dict_['key1'], Parameter) + + def test_update(self, actor, dict_): + dict_['key1'] = 'value1' + + new_dict = {'key2': 'value2'} + dict_.update(new_dict) + assert len(dict_) == 2 + assert dict_['key2'] == 'value2' + assert isinstance(actor.dict_['key2'], Parameter) + + new_dict = {} + new_dict.update(dict_) + assert new_dict['key1'] == dict_['key1'] + + def test_copy(self, dict_): + dict_['key1'] = 'value1' + + new_dict = dict_.copy() + assert new_dict is not dict_ + assert new_dict == dict_ + + dict_['key1'] = 'value2' + assert new_dict['key1'] == 'value1' + assert dict_['key1'] == 'value2' + + def test_clear(self, dict_): + dict_['key1'] = 'value1' + dict_.clear() + + assert len(dict_) == 0 + + +class TestList(ContextSugaring): + + def test_append(self, actor, list_): + list_.append(Parameter.wrap('name', 'value1')) + list_.append('value2') + assert len(actor.list_) == 2 + assert len(list_) == 2 + assert isinstance(actor.list_[0], Parameter) + assert list_[0] == 'value1' + + assert isinstance(actor.list_[1], Parameter) + assert list_[1] == 'value2' + + list_[0] = 'new_value1' + list_[1] = 'new_value2' + assert isinstance(actor.list_[1], Parameter) + assert isinstance(actor.list_[1], Parameter) + assert list_[0] == 'new_value1' + assert list_[1] == 'new_value2' + + def test_iter(self, list_): + list_.append('value1') + list_.append('value2') + assert sorted(list_) == sorted(['value1', 'value2']) + + def test_insert(self, actor, list_): + list_.append('value1') + list_.insert(0, 'value2') + list_.insert(2, 'value3') + list_.insert(10, 'value4') + assert sorted(list_) == sorted(['value1', 'value2', 'value3', 'value4']) + assert len(actor.list_) == 4 + + def test_set(self, list_): + list_.append('value1') + list_.append('value2') + + list_[1] = 'value3' + assert len(list_) == 2 + assert sorted(list_) == sorted(['value1', 'value3']) + + def test_insert_into_nested(self, actor, list_): + list_.append([]) + + list_[0].append('inner_item') + assert isinstance(actor.list_[0], Parameter) + assert len(list_) == 1 + assert list_[0][0] == 'inner_item' + + list_[0].append('new_item') + assert isinstance(actor.list_[0], Parameter) + assert len(list_) == 1 + assert list_[0][1] == 'new_item' + + assert list_[0] == ['inner_item', 'new_item'] + assert ['inner_item', 'new_item'] == list_[0] + + +class TestDictList(ContextSugaring): + def test_dict_in_list(self, actor, list_): + list_.append({}) + assert len(list_) == 1 + assert isinstance(actor.list_[0], Parameter) + assert actor.list_[0].value == {} + + list_[0]['key'] = 'value' + assert list_[0]['key'] == 'value' + assert len(actor.list_) == 1 + assert isinstance(actor.list_[0], Parameter) + assert actor.list_[0].value['key'] == 'value' + + def test_list_in_dict(self, actor, dict_): + dict_['key'] = [] + assert len(dict_) == 1 + assert isinstance(actor.dict_['key'], Parameter) + assert actor.dict_['key'].value == [] + + dict_['key'].append('value') + assert dict_['key'][0] == 'value' + assert len(actor.dict_) == 1 + assert isinstance(actor.dict_['key'], Parameter) + assert actor.dict_['key'].value[0] == 'value' http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/0b1a306f/tests/orchestrator/context/test_operation.py ---------------------------------------------------------------------- diff --git a/tests/orchestrator/context/test_operation.py b/tests/orchestrator/context/test_operation.py index 86e4a24..581e230 100644 --- a/tests/orchestrator/context/test_operation.py +++ b/tests/orchestrator/context/test_operation.py @@ -25,9 +25,7 @@ from aria import ( operation, ) from aria.orchestrator import context -from aria.orchestrator.context import common from aria.orchestrator.workflows import api -from aria.modeling.models import Parameter import tests from tests import ( @@ -498,237 +496,3 @@ def attribute_consuming_operation(ctx, holder_path, **_): holder = helpers.FilesystemDataHolder(holder_path) ctx.target_node.attributes.update(ctx.source_node.attributes) holder.update(**ctx.target_node.attributes) - - -class MockActor(object): - def __init__(self): - self.dict_ = {} - self.list_ = [] - - -class MockModel(object): - - def __init__(self): - self.parameter = type('MockModel', (object, ), {'model_cls': Parameter, - 'put': lambda *args, **kwargs: None, - 'update': lambda *args, **kwargs: None})() - - -class ContextSugaring(object): - - @pytest.fixture - def actor(self): - return MockActor() - - @pytest.fixture - def model(self): - return MockModel() - - @pytest.fixture - def dict_(self, actor, model): - return common._InstrumentedDict(model, actor, 'dict_', item_cls=Parameter) - - @pytest.fixture - def list_(self, actor, model): - return common._InstrumentedList(model, actor, field_name='list_', item_cls=Parameter) - - -class TestDict(ContextSugaring): - - def test_keys(self, actor, dict_): - dict_.update( - { - 'key1': Parameter.wrap('key1', 'value1'), - 'key2': Parameter.wrap('key2', 'value2') - } - ) - assert sorted(dict_.keys()) == sorted(['key1', 'key2']) == sorted(actor.dict_.keys()) - - def test_values(self, actor, dict_): - dict_.update({ - 'key1': Parameter.wrap('key1', 'value1'), - 'key2': Parameter.wrap('key1', 'value2') - }) - assert (sorted(dict_.values()) == - sorted(['value1', 'value2']) == - sorted(v.value for v in actor.dict_.values())) - - def test_items(self, dict_): - dict_.update({ - 'key1': Parameter.wrap('key1', 'value1'), - 'key2': Parameter.wrap('key1', 'value2') - }) - assert sorted(dict_.items()) == sorted([('key1', 'value1'), ('key2', 'value2')]) - - def test_iter(self, actor, dict_): - dict_.update({ - 'key1': Parameter.wrap('key1', 'value1'), - 'key2': Parameter.wrap('key1', 'value2') - }) - assert sorted(list(dict_)) == sorted(['key1', 'key2']) == sorted(actor.dict_.keys()) - - def test_bool(self, dict_): - assert not dict_ - dict_.update({ - 'key1': Parameter.wrap('key1', 'value1'), - 'key2': Parameter.wrap('key1', 'value2') - }) - assert dict_ - - def test_set_item(self, actor, dict_): - dict_['key1'] = Parameter.wrap('key1', 'value1') - assert dict_['key1'] == 'value1' == actor.dict_['key1'].value - assert isinstance(actor.dict_['key1'], Parameter) - - def test_nested(self, actor, dict_): - dict_['key'] = {} - assert isinstance(actor.dict_['key'], Parameter) - assert dict_['key'] == actor.dict_['key'].value == {} - - dict_['key']['inner_key'] = 'value' - - assert len(dict_) == 1 - assert 'inner_key' in dict_['key'] - assert dict_['key']['inner_key'] == 'value' - assert dict_['key'].keys() == ['inner_key'] - assert dict_['key'].values() == ['value'] - assert dict_['key'].items() == [('inner_key', 'value')] - assert isinstance(actor.dict_['key'], Parameter) - assert isinstance(dict_['key'], common._InstrumentedDict) - - dict_['key'].update({'updated_key': 'updated_value'}) - assert len(dict_) == 1 - assert 'updated_key' in dict_['key'] - assert dict_['key']['updated_key'] == 'updated_value' - assert sorted(dict_['key'].keys()) == sorted(['inner_key', 'updated_key']) - assert sorted(dict_['key'].values()) == sorted(['value', 'updated_value']) - assert sorted(dict_['key'].items()) == sorted([('inner_key', 'value'), - ('updated_key', 'updated_value')]) - assert isinstance(actor.dict_['key'], Parameter) - assert isinstance(dict_['key'], common._InstrumentedDict) - - dict_.update({'key': 'override_value'}) - assert len(dict_) == 1 - assert 'key' in dict_ - assert dict_['key'] == 'override_value' - assert len(actor.dict_) == 1 - assert isinstance(actor.dict_['key'], Parameter) - assert actor.dict_['key'].value == 'override_value' - - def test_get_item(self, actor,dict_): - dict_['key1'] = Parameter.wrap('key1', 'value1') - assert isinstance(actor.dict_['key1'], Parameter) - - def test_update(self, actor, dict_): - dict_['key1'] = 'value1' - - new_dict = {'key2': 'value2'} - dict_.update(new_dict) - assert len(dict_) == 2 - assert dict_['key2'] == 'value2' - assert isinstance(actor.dict_['key2'], Parameter) - - new_dict = {} - new_dict.update(dict_) - assert new_dict['key1'] == dict_['key1'] - - def test_copy(self, dict_): - dict_['key1'] = 'value1' - - new_dict = dict_.copy() - assert new_dict is not dict_ - assert new_dict == dict_ - - dict_['key1'] = 'value2' - assert new_dict['key1'] == 'value1' - assert dict_['key1'] == 'value2' - - def test_clear(self, dict_): - dict_['key1'] = 'value1' - dict_.clear() - - assert len(dict_) == 0 - - -class TestList(ContextSugaring): - - def test_append(self, actor, list_): - list_.append(Parameter.wrap('name', 'value1')) - list_.append('value2') - assert len(actor.list_) == 2 - assert len(list_) == 2 - assert isinstance(actor.list_[0], Parameter) - assert list_[0] == 'value1' - - assert isinstance(actor.list_[1], Parameter) - assert list_[1] == 'value2' - - list_[0] = 'new_value1' - list_[1] = 'new_value2' - assert isinstance(actor.list_[1], Parameter) - assert isinstance(actor.list_[1], Parameter) - assert list_[0] == 'new_value1' - assert list_[1] == 'new_value2' - - def test_iter(self, list_): - list_.append('value1') - list_.append('value2') - assert sorted(list_) == sorted(['value1', 'value2']) - - def test_insert(self, actor, list_): - list_.append('value1') - list_.insert(0, 'value2') - list_.insert(2, 'value3') - list_.insert(10, 'value4') - assert sorted(list_) == sorted(['value1', 'value2', 'value3', 'value4']) - assert len(actor.list_) == 4 - - def test_set(self, list_): - list_.append('value1') - list_.append('value2') - - list_[1] = 'value3' - assert len(list_) == 2 - assert sorted(list_) == sorted(['value1', 'value3']) - - def test_insert_into_nested(self, actor, list_): - list_.append([]) - - list_[0].append('inner_item') - assert isinstance(actor.list_[0], Parameter) - assert len(list_) == 1 - assert list_[0][0] == 'inner_item' - - list_[0].append('new_item') - assert isinstance(actor.list_[0], Parameter) - assert len(list_) == 1 - assert list_[0][1] == 'new_item' - - assert list_[0] == ['inner_item', 'new_item'] - assert ['inner_item', 'new_item'] == list_[0] - - -class TestDictList(ContextSugaring): - def test_dict_in_list(self, actor, list_): - list_.append({}) - assert len(list_) == 1 - assert isinstance(actor.list_[0], Parameter) - assert actor.list_[0].value == {} - - list_[0]['key'] = 'value' - assert list_[0]['key'] == 'value' - assert len(actor.list_) == 1 - assert isinstance(actor.list_[0], Parameter) - assert actor.list_[0].value['key'] == 'value' - - def test_list_in_dict(self, actor, dict_): - dict_['key'] = [] - assert len(dict_) == 1 - assert isinstance(actor.dict_['key'], Parameter) - assert actor.dict_['key'].value == [] - - dict_['key'].append('value') - assert dict_['key'][0] == 'value' - assert len(actor.dict_) == 1 - assert isinstance(actor.dict_['key'], Parameter) - assert actor.dict_['key'].value[0] == 'value'