def test_simplified_literal_str(self) -> None: """Test simplified literal str.""" assert (VariableValueConcatenation([VariableValueLiteral("foo") ]).simplified.value == "foo") assert (VariableValueConcatenation( [VariableValueLiteral("foo"), VariableValueLiteral("bar")]).simplified.value == "foobar")
def test_simplified_concat(self) -> None: """Test simplified concatenation.""" assert (VariableValueConcatenation([ VariableValueLiteral("foo"), VariableValueConcatenation( [VariableValueLiteral("bar"), VariableValueLiteral("foo")]), ]).simplified.value == "foobarfoo")
def test_resolved(self) -> None: """Test resolved.""" assert VariableValueConcatenation([MagicMock(resolved=True) ]).resolved is True assert VariableValueConcatenation([MagicMock(resolved=False) ]).resolved is False assert (VariableValueConcatenation( [MagicMock(resolved=True), MagicMock(resolved=False)]).resolved is False)
def test_value_multiple(self) -> None: """Test multiple.""" assert (VariableValueConcatenation( [VariableValueLiteral("foo"), VariableValueLiteral("bar")]).value == "foobar") assert (VariableValueConcatenation( [VariableValueLiteral(13), VariableValueLiteral("/test")] # type: ignore ).value == "13/test") assert (VariableValueConcatenation( [VariableValueLiteral(5), VariableValueLiteral(13)]).value == "513") with pytest.raises(InvalidLookupConcatenation): VariableValueConcatenation( [VariableValueLiteral(True), VariableValueLiteral("test")] # type: ignore ).value
def test_setitem(self) -> None: """Test __setitem__.""" obj = VariableValueConcatenation(["test-val0", "test-val1"]) # type: ignore obj[0] = "val0" # type: ignore assert obj[0] == "val0" obj[:2] = ["val0", "val1"] # type: ignore assert obj[1] == "val1"
def test_resolve(self, cfngin_context: MockCFNginContext, mocker: MockerFixture) -> None: """Test resolve.""" mock_provider = MagicMock() mock_resolve = mocker.patch.object(VariableValueLiteral, "resolve", return_value=None) obj = VariableValueConcatenation([VariableValueLiteral("val0")]) assert not obj.resolve( cfngin_context, provider=mock_provider, variables={"var": "something"}, # type: ignore kwarg="test", ) mock_resolve.assert_called_once_with( cfngin_context, provider=mock_provider, variables={"var": "something"}, kwarg="test", )
def test_simplified_literal_int(self) -> None: """Test simplified literal int.""" assert (VariableValueConcatenation([VariableValueLiteral(13) ]).simplified.value == 13)
def test_simplified_literal_empty(self) -> None: """Test simplified literal empty.""" assert (VariableValueConcatenation([VariableValueLiteral("") ]).simplified.value == "")
def test_simplified_literal_bool(self) -> None: """Test simplified literal bool.""" assert (VariableValueConcatenation([VariableValueLiteral(True) ]).simplified.value is True) assert (VariableValueConcatenation([VariableValueLiteral(False) ]).simplified.value is False)
def test_simplified_list(self) -> None: """Test simplified list.""" assert [ i.value for i in VariableValueConcatenation( [VariableValueList(["foo", "bar"])]).simplified ] == ["foo", "bar"]
def test_dependencies(self) -> None: """Test dependencies.""" data = [MagicMock(dependencies={"test"})] obj = VariableValueConcatenation(data) assert obj.dependencies == {"test"}
def test_repr(self) -> None: """Test __repr__.""" obj = VariableValueConcatenation(["val0", "val1"]) # type: ignore assert repr(obj) == "Concatenation['val0', 'val1']" # type: ignore
def test_len(self) -> None: """Test __len__.""" obj = VariableValueConcatenation(["val0", "val1"]) # type: ignore assert len(obj) == 2 # type: ignore
def test_iter(self) -> None: """Test __iter__.""" obj = VariableValueConcatenation(["val0", "val1"]) # type: ignore assert list(iter(obj)) == ["val0", "val1"] # type: ignore
def test_init(self) -> None: """Test __init__.""" data = [VariableValueLiteral("test")] obj = VariableValueConcatenation(data) assert obj._data == data assert obj.variable_type == "cfngin"
def test_getitem(self) -> None: """Test __getitem__.""" obj = VariableValueConcatenation(["val0", "val1"]) # type: ignore assert obj[1] == "val1" assert obj[:2] == ["val0", "val1"]
def test_value_single(self) -> None: """Test value single.""" assert VariableValueConcatenation([VariableValueLiteral("foo") ]).value == "foo" assert VariableValueConcatenation([VariableValueLiteral(13) ]).value == 13
def test_delitem(self) -> None: """Test __delitem__.""" obj = VariableValueConcatenation(["val0", "val1"]) # type: ignore assert "val1" in obj._data del obj[1] assert "val1" not in obj._data