You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@ariatosca.apache.org by mx...@apache.org on 2017/05/22 14:52:10 UTC
[4/4] incubator-ariatosca git commit: created new module and linting
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'