A recent change to output deserialization resulted in secrets being returned unwrapped. This change addresses the regression, ensuring any unwrapped secret values are rewrapped before being returned.
995 lines
37 KiB
Python
995 lines
37 KiB
Python
# Copyright 2016-2020, Pulumi Corporation.
|
|
#
|
|
# Licensed 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 unittest
|
|
from typing import Any, Dict, List, NamedTuple, Mapping, Optional, Sequence
|
|
|
|
from pulumi.runtime import rpc
|
|
import pulumi
|
|
|
|
camel_case_to_snake_case = {
|
|
"firstArg": "first_arg",
|
|
"secondArg": "second_arg",
|
|
}
|
|
|
|
|
|
def translate_output_property(prop: str) -> str:
|
|
return camel_case_to_snake_case.get(prop) or prop
|
|
|
|
|
|
@pulumi.output_type
|
|
class Foo(dict):
|
|
first_arg: str = pulumi.property("firstArg")
|
|
second_arg: float = pulumi.property("secondArg")
|
|
|
|
def _translate_property(self, prop: str) -> str:
|
|
return camel_case_to_snake_case.get(prop) or prop
|
|
|
|
|
|
@pulumi.output_type
|
|
class Bar(dict):
|
|
third_arg: Foo = pulumi.property("thirdArg")
|
|
third_optional_arg: Optional[Foo] = pulumi.property("thirdOptionalArg")
|
|
|
|
fourth_arg: Dict[str, Foo] = pulumi.property("fourthArg")
|
|
fourth_optional_arg: Dict[str, Optional[Foo]] = pulumi.property("fourthOptionalArg")
|
|
|
|
fifth_arg: List[Foo] = pulumi.property("fifthArg")
|
|
fifth_optional_arg: List[Optional[Foo]] = pulumi.property("fifthOptionalArg")
|
|
|
|
sixth_arg: Dict[str, List[Foo]] = pulumi.property("sixthArg")
|
|
sixth_optional_arg: Dict[str, Optional[List[Foo]]] = pulumi.property("sixthOptionalArg")
|
|
sixth_optional_optional_arg: Dict[str, Optional[List[Optional[Foo]]]] = pulumi.property("sixthOptionalOptionalArg")
|
|
|
|
seventh_arg: List[Dict[str, Foo]] = pulumi.property("seventhArg")
|
|
seventh_optional_arg: List[Optional[Dict[str, Foo]]] = pulumi.property("seventhOptionalArg")
|
|
seventh_optional_optional_arg: List[Optional[Dict[str, Optional[Foo]]]] = pulumi.property("seventhOptionalOptionalArg")
|
|
|
|
eighth_arg: List[Dict[str, List[Foo]]] = pulumi.property("eighthArg")
|
|
eighth_optional_arg: List[Optional[Dict[str, List[Foo]]]] = pulumi.property("eighthOptionalArg")
|
|
eighth_optional_optional_arg: List[Optional[Dict[str, Optional[List[Foo]]]]] = pulumi.property("eighthOptionalOptionalArg")
|
|
eighth_optional_optional_optional_arg: List[Optional[Dict[str, Optional[List[Optional[Foo]]]]]] = pulumi.property("eighthOptionalOptionalOptionalArg")
|
|
|
|
def _translate_property(self, prop: str) -> str:
|
|
return camel_case_to_snake_case.get(prop) or prop
|
|
|
|
|
|
@pulumi.output_type
|
|
class BarMappingSequence(dict):
|
|
third_arg: Foo = pulumi.property("thirdArg")
|
|
third_optional_arg: Optional[Foo] = pulumi.property("thirdOptionalArg")
|
|
|
|
fourth_arg: Mapping[str, Foo] = pulumi.property("fourthArg")
|
|
fourth_optional_arg: Mapping[str, Optional[Foo]] = pulumi.property("fourthOptionalArg")
|
|
|
|
fifth_arg: Sequence[Foo] = pulumi.property("fifthArg")
|
|
fifth_optional_arg: Sequence[Optional[Foo]] = pulumi.property("fifthOptionalArg")
|
|
|
|
sixth_arg: Mapping[str, Sequence[Foo]] = pulumi.property("sixthArg")
|
|
sixth_optional_arg: Mapping[str, Optional[Sequence[Foo]]] = pulumi.property("sixthOptionalArg")
|
|
sixth_optional_optional_arg: Mapping[str, Optional[Sequence[Optional[Foo]]]] = pulumi.property("sixthOptionalOptionalArg")
|
|
|
|
seventh_arg: Sequence[Mapping[str, Foo]] = pulumi.property("seventhArg")
|
|
seventh_optional_arg: Sequence[Optional[Mapping[str, Foo]]] = pulumi.property("seventhOptionalArg")
|
|
seventh_optional_optional_arg: Sequence[Optional[Mapping[str, Optional[Foo]]]] = pulumi.property("seventhOptionalOptionalArg")
|
|
|
|
eighth_arg: Sequence[Mapping[str, Sequence[Foo]]] = pulumi.property("eighthArg")
|
|
eighth_optional_arg: Sequence[Optional[Mapping[str, Sequence[Foo]]]] = pulumi.property("eighthOptionalArg")
|
|
eighth_optional_optional_arg: Sequence[Optional[Mapping[str, Optional[Sequence[Foo]]]]] = pulumi.property("eighthOptionalOptionalArg")
|
|
eighth_optional_optional_optional_arg: Sequence[Optional[Mapping[str, Optional[Sequence[Optional[Foo]]]]]] = pulumi.property("eighthOptionalOptionalOptionalArg")
|
|
|
|
def _translate_property(self, prop: str) -> str:
|
|
return camel_case_to_snake_case.get(prop) or prop
|
|
|
|
|
|
@pulumi.output_type
|
|
class BarDeclared(dict):
|
|
def __init__(self,
|
|
third_arg: Foo,
|
|
third_optional_arg: Optional[Foo],
|
|
fourth_arg: Dict[str, Foo],
|
|
fourth_optional_arg: Dict[str, Optional[Foo]],
|
|
fifth_arg: List[Foo],
|
|
fifth_optional_arg: List[Optional[Foo]],
|
|
sixth_arg: Dict[str, List[Foo]],
|
|
sixth_optional_arg: Dict[str, Optional[List[Foo]]],
|
|
sixth_optional_optional_arg: Dict[str, Optional[List[Optional[Foo]]]],
|
|
seventh_arg: List[Dict[str, Foo]],
|
|
seventh_optional_arg: List[Optional[Dict[str, Foo]]],
|
|
seventh_optional_optional_arg: List[Optional[Dict[str, Optional[Foo]]]],
|
|
eighth_arg: List[Dict[str, List[Foo]]],
|
|
eighth_optional_arg: List[Optional[Dict[str, List[Foo]]]],
|
|
eighth_optional_optional_arg: List[Optional[Dict[str, Optional[List[Foo]]]]],
|
|
eighth_optional_optional_optional_arg: List[Optional[Dict[str, Optional[List[Optional[Foo]]]]]]):
|
|
pulumi.set(self, "third_arg", third_arg)
|
|
pulumi.set(self, "third_optional_arg", third_optional_arg)
|
|
pulumi.set(self, "fourth_arg", fourth_arg)
|
|
pulumi.set(self, "fourth_optional_arg", fourth_optional_arg)
|
|
pulumi.set(self, "fifth_arg", fifth_arg)
|
|
pulumi.set(self, "fifth_optional_arg", fifth_optional_arg)
|
|
pulumi.set(self, "sixth_arg", sixth_arg)
|
|
pulumi.set(self, "sixth_optional_arg", sixth_optional_arg)
|
|
pulumi.set(self, "sixth_optional_optional_arg", sixth_optional_optional_arg)
|
|
pulumi.set(self, "seventh_arg", seventh_arg)
|
|
pulumi.set(self, "seventh_optional_arg", seventh_optional_arg)
|
|
pulumi.set(self, "seventh_optional_optional_arg", seventh_optional_optional_arg)
|
|
pulumi.set(self, "eighth_arg", eighth_arg)
|
|
pulumi.set(self, "eighth_optional_arg", eighth_optional_arg)
|
|
pulumi.set(self, "eighth_optional_optional_arg", eighth_optional_optional_arg)
|
|
pulumi.set(self, "eighth_optional_optional_optional_arg", eighth_optional_optional_optional_arg)
|
|
|
|
@property
|
|
@pulumi.getter(name="thirdArg")
|
|
def third_arg(self) -> Foo:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="thirdOptionalArg")
|
|
def third_optional_arg(self) -> Optional[Foo]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="fourthArg")
|
|
def fourth_arg(self) -> Dict[str, Foo]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="fourthOptionalArg")
|
|
def fourth_optional_arg(self) -> Dict[str, Optional[Foo]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="fifthArg")
|
|
def fifth_arg(self) -> List[Foo]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="fifthOptionalArg")
|
|
def fifth_optional_arg(self) -> List[Optional[Foo]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="sixthArg")
|
|
def sixth_arg(self) -> Dict[str, List[Foo]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="sixthOptionalArg")
|
|
def sixth_optional_arg(self) -> Dict[str, Optional[List[Foo]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="sixthOptionalOptionalArg")
|
|
def sixth_optional_optional_arg(self) -> Dict[str, Optional[List[Optional[Foo]]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="seventhArg")
|
|
def seventh_arg(self) -> List[Dict[str, Foo]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="seventhOptionalArg")
|
|
def seventh_optional_arg(self) -> List[Optional[Dict[str, Foo]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="seventhOptionalOptionalArg")
|
|
def seventh_optional_optional_arg(self) -> List[Optional[Dict[str, Optional[Foo]]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="eighthArg")
|
|
def eighth_arg(self) -> List[Dict[str, List[Foo]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="eighthOptionalArg")
|
|
def eighth_optional_arg(self) -> List[Optional[Dict[str, List[Foo]]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="eighthOptionalOptionalArg")
|
|
def eighth_optional_optional_arg(self) -> List[Optional[Dict[str, Optional[List[Foo]]]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="eighthOptionalOptionalOptionalArg")
|
|
def eighth_optional_optional_optional_arg(self) -> List[Optional[Dict[str, Optional[List[Optional[Foo]]]]]]:
|
|
...
|
|
|
|
def _translate_property(self, prop: str) -> str:
|
|
return camel_case_to_snake_case.get(prop) or prop
|
|
|
|
|
|
@pulumi.output_type
|
|
class BarMappingSequenceDeclared(dict):
|
|
def __init__(self,
|
|
third_arg: Foo,
|
|
third_optional_arg: Optional[Foo],
|
|
fourth_arg: Mapping[str, Foo],
|
|
fourth_optional_arg: Dict[str, Optional[Foo]],
|
|
fifth_arg: Sequence[Foo],
|
|
fifth_optional_arg: Sequence[Optional[Foo]],
|
|
sixth_arg: Mapping[str, Sequence[Foo]],
|
|
sixth_optional_arg: Mapping[str, Optional[Sequence[Foo]]],
|
|
sixth_optional_optional_arg: Mapping[str, Optional[Sequence[Optional[Foo]]]],
|
|
seventh_arg: Sequence[Mapping[str, Foo]],
|
|
seventh_optional_arg: Sequence[Optional[Mapping[str, Foo]]],
|
|
seventh_optional_optional_arg: Sequence[Optional[Mapping[str, Optional[Foo]]]],
|
|
eighth_arg: Sequence[Mapping[str, Sequence[Foo]]],
|
|
eighth_optional_arg: Sequence[Optional[Mapping[str, Sequence[Foo]]]],
|
|
eighth_optional_optional_arg: Sequence[Optional[Mapping[str, Optional[Sequence[Foo]]]]],
|
|
eighth_optional_optional_optional_arg: Sequence[Optional[Mapping[str, Optional[Sequence[Optional[Foo]]]]]]):
|
|
pulumi.set(self, "third_arg", third_arg)
|
|
pulumi.set(self, "third_optional_arg", third_optional_arg)
|
|
pulumi.set(self, "fourth_arg", fourth_arg)
|
|
pulumi.set(self, "fourth_optional_arg", fourth_optional_arg)
|
|
pulumi.set(self, "fifth_arg", fifth_arg)
|
|
pulumi.set(self, "fifth_optional_arg", fifth_optional_arg)
|
|
pulumi.set(self, "sixth_arg", sixth_arg)
|
|
pulumi.set(self, "sixth_optional_arg", sixth_optional_arg)
|
|
pulumi.set(self, "sixth_optional_optional_arg", sixth_optional_optional_arg)
|
|
pulumi.set(self, "seventh_arg", seventh_arg)
|
|
pulumi.set(self, "seventh_optional_arg", seventh_optional_arg)
|
|
pulumi.set(self, "seventh_optional_optional_arg", seventh_optional_optional_arg)
|
|
pulumi.set(self, "eighth_arg", eighth_arg)
|
|
pulumi.set(self, "eighth_optional_arg", eighth_optional_arg)
|
|
pulumi.set(self, "eighth_optional_optional_arg", eighth_optional_optional_arg)
|
|
pulumi.set(self, "eighth_optional_optional_optional_arg", eighth_optional_optional_optional_arg)
|
|
|
|
@property
|
|
@pulumi.getter(name="thirdArg")
|
|
def third_arg(self) -> Foo:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="thirdOptionalArg")
|
|
def third_optional_arg(self) -> Optional[Foo]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="fourthArg")
|
|
def fourth_arg(self) -> Mapping[str, Foo]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="fourthOptionalArg")
|
|
def fourth_optional_arg(self) -> Mapping[str, Optional[Foo]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="fifthArg")
|
|
def fifth_arg(self) -> Sequence[Foo]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="fifthOptionalArg")
|
|
def fifth_optional_arg(self) -> Sequence[Optional[Foo]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="sixthArg")
|
|
def sixth_arg(self) -> Mapping[str, Sequence[Foo]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="sixthOptionalArg")
|
|
def sixth_optional_arg(self) -> Mapping[str, Optional[Sequence[Foo]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="sixthOptionalOptionalArg")
|
|
def sixth_optional_optional_arg(self) -> Mapping[str, Optional[Sequence[Optional[Foo]]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="seventhArg")
|
|
def seventh_arg(self) -> Sequence[Mapping[str, Foo]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="seventhOptionalArg")
|
|
def seventh_optional_arg(self) -> Sequence[Optional[Mapping[str, Foo]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="seventhOptionalOptionalArg")
|
|
def seventh_optional_optional_arg(self) -> Sequence[Optional[Mapping[str, Optional[Foo]]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="eighthArg")
|
|
def eighth_arg(self) -> Sequence[Mapping[str, Sequence[Foo]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="eighthOptionalArg")
|
|
def eighth_optional_arg(self) -> Sequence[Optional[Mapping[str, Sequence[Foo]]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="eighthOptionalOptionalArg")
|
|
def eighth_optional_optional_arg(self) -> Sequence[Optional[Mapping[str, Optional[Sequence[Foo]]]]]:
|
|
...
|
|
|
|
@property
|
|
@pulumi.getter(name="eighthOptionalOptionalOptionalArg")
|
|
def eighth_optional_optional_optional_arg(self) -> Sequence[Optional[Mapping[str, Optional[Sequence[Optional[Foo]]]]]]:
|
|
...
|
|
|
|
def _translate_property(self, prop: str) -> str:
|
|
return camel_case_to_snake_case.get(prop) or prop
|
|
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeStr(dict):
|
|
value: str = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredStr(dict):
|
|
def __init__(self, value: str):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> str:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalStr(dict):
|
|
value: Optional[str] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalStr(dict):
|
|
def __init__(self, value: Optional[str]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[str]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDictStr(dict):
|
|
value: Dict[str, str] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeMappingStr(dict):
|
|
value: Mapping[str, str] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredDictStr(dict):
|
|
def __init__(self, value: Dict[str, str]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Dict[str, str]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredMappingStr(dict):
|
|
def __init__(self, value: Mapping[str, str]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Mapping[str, str]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalDictStr(dict):
|
|
value: Optional[Dict[str, str]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalMappingStr(dict):
|
|
value: Optional[Mapping[str, str]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalDictStr(dict):
|
|
def __init__(self, value: Optional[Dict[str, str]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[Dict[str, str]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalMappingStr(dict):
|
|
def __init__(self, value: Optional[Mapping[str, str]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[Mapping[str, str]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDictOptionalStr(dict):
|
|
value: Dict[str, Optional[str]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeMappingOptionalStr(dict):
|
|
value: Mapping[str, Optional[str]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredDictOptionalStr(dict):
|
|
def __init__(self, value: Dict[str, Optional[str]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Dict[str, Optional[str]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredMappingOptionalStr(dict):
|
|
def __init__(self, value: Mapping[str, Optional[str]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Mapping[str, Optional[str]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalDictOptionalStr(dict):
|
|
value: Optional[Dict[str, Optional[str]]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalMappingOptionalStr(dict):
|
|
value: Optional[Mapping[str, Optional[str]]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalDictOptionalStr(dict):
|
|
def __init__(self, value: Optional[Dict[str, Optional[str]]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[Dict[str, Optional[str]]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalMappingOptionalStr(dict):
|
|
def __init__(self, value: Optional[Mapping[str, Optional[str]]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[Mapping[str, Optional[str]]]:
|
|
...
|
|
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeListStr(dict):
|
|
value: List[str] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeSequenceStr(dict):
|
|
value: Sequence[str] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredListStr(dict):
|
|
def __init__(self, value: List[str]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> List[str]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredSequenceStr(dict):
|
|
def __init__(self, value: Sequence[str]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Sequence[str]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalListStr(dict):
|
|
value: Optional[List[str]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalSequenceStr(dict):
|
|
value: Optional[Sequence[str]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalListStr(dict):
|
|
def __init__(self, value: Optional[List[str]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[List[str]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalSequenceStr(dict):
|
|
def __init__(self, value: Optional[Sequence[str]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[Sequence[str]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeListOptionalStr(dict):
|
|
value: List[Optional[str]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeSequenceOptionalStr(dict):
|
|
value: Sequence[Optional[str]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredListOptionalStr(dict):
|
|
def __init__(self, value: List[Optional[str]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> List[Optional[str]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredSequenceOptionalStr(dict):
|
|
def __init__(self, value: Sequence[Optional[str]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Sequence[Optional[str]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalListOptionalStr(dict):
|
|
value: Optional[List[Optional[str]]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeOptionalSequenceOptionalStr(dict):
|
|
value: Optional[Sequence[Optional[str]]] = pulumi.property("value")
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalListOptionalStr(dict):
|
|
def __init__(self, value: Optional[List[Optional[str]]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[List[Optional[str]]]:
|
|
...
|
|
|
|
@pulumi.output_type
|
|
class InvalidTypeDeclaredOptionalSequenceOptionalStr(dict):
|
|
def __init__(self, value: Optional[Sequence[Optional[str]]]):
|
|
pulumi.set(self, "value", value)
|
|
|
|
@property
|
|
@pulumi.getter
|
|
def value(self) -> Optional[Sequence[Optional[str]]]:
|
|
...
|
|
|
|
|
|
@pulumi.output_type
|
|
class OutputTypeWithAny(dict):
|
|
value_dict: Any
|
|
value_list: Any
|
|
value_dict_dict: Dict[str, Any]
|
|
value_dict_mapping: Mapping[str, Any]
|
|
value_list_list: List[Any]
|
|
value_list_sequence: Sequence[Any]
|
|
value_str: Any
|
|
|
|
|
|
class TranslateOutputPropertiesTests(unittest.TestCase):
|
|
def test_translate(self):
|
|
output = {
|
|
"firstArg": "hello",
|
|
"secondArg": 42,
|
|
}
|
|
result = rpc.translate_output_properties(output, translate_output_property, Foo)
|
|
self.assertIsInstance(result, Foo)
|
|
self.assertEqual(result.first_arg, "hello")
|
|
self.assertEqual(result["first_arg"], "hello")
|
|
self.assertEqual(result.second_arg, 42)
|
|
self.assertEqual(result["second_arg"], 42)
|
|
|
|
def test_nested_types(self):
|
|
def assertFoo(val, first_arg, second_arg):
|
|
self.assertIsInstance(val, Foo)
|
|
self.assertEqual(val.first_arg, first_arg)
|
|
self.assertEqual(val["first_arg"], first_arg)
|
|
self.assertEqual(val.second_arg, second_arg)
|
|
self.assertEqual(val["second_arg"], second_arg)
|
|
|
|
output = {
|
|
"thirdArg": {
|
|
"firstArg": "hello",
|
|
"secondArg": 42,
|
|
},
|
|
"thirdOptionalArg": {
|
|
"firstArg": "hello-opt",
|
|
"secondArg": 142,
|
|
},
|
|
"fourthArg": {
|
|
"foo": {
|
|
"firstArg": "hi",
|
|
"secondArg": 41,
|
|
},
|
|
},
|
|
"fourthOptionalArg": {
|
|
"foo": {
|
|
"firstArg": "hi-opt",
|
|
"secondArg": 141,
|
|
},
|
|
},
|
|
"fifthArg": [{
|
|
"firstArg": "bye",
|
|
"secondArg": 40,
|
|
}],
|
|
"fifthOptionalArg": [{
|
|
"firstArg": "bye-opt",
|
|
"secondArg": 140,
|
|
}],
|
|
"sixthArg": {
|
|
"bar": [{
|
|
"firstArg": "goodbye",
|
|
"secondArg": 39,
|
|
}],
|
|
},
|
|
"sixthOptionalArg": {
|
|
"bar": [{
|
|
"firstArg": "goodbye-opt",
|
|
"secondArg": 139,
|
|
}],
|
|
},
|
|
"sixthOptionalOptionalArg": {
|
|
"bar": [{
|
|
"firstArg": "goodbye-opt-opt",
|
|
"secondArg": 1139,
|
|
}],
|
|
},
|
|
"seventhArg": [{
|
|
"baz": {
|
|
"firstArg": "adios",
|
|
"secondArg": 38,
|
|
},
|
|
}],
|
|
"seventhOptionalArg": [{
|
|
"baz": {
|
|
"firstArg": "adios-opt",
|
|
"secondArg": 138,
|
|
},
|
|
}],
|
|
"seventhOptionalOptionalArg": [{
|
|
"baz": {
|
|
"firstArg": "adios-opt-opt",
|
|
"secondArg": 1138,
|
|
},
|
|
}],
|
|
"eighthArg": [{
|
|
"blah": [{
|
|
"firstArg": "farewell",
|
|
"secondArg": 37,
|
|
}],
|
|
}],
|
|
"eighthOptionalArg": [{
|
|
"blah": [{
|
|
"firstArg": "farewell-opt",
|
|
"secondArg": 137,
|
|
}],
|
|
}],
|
|
"eighthOptionalOptionalArg": [{
|
|
"blah": [{
|
|
"firstArg": "farewell-opt-opt",
|
|
"secondArg": 1137,
|
|
}],
|
|
}],
|
|
"eighthOptionalOptionalOptionalArg": [{
|
|
"blah": [{
|
|
"firstArg": "farewell-opt-opt-opt",
|
|
"secondArg": 11137,
|
|
}],
|
|
}],
|
|
}
|
|
|
|
for typ in [Bar, BarMappingSequence, BarDeclared, BarMappingSequenceDeclared]:
|
|
result = rpc.translate_output_properties(output, translate_output_property, typ)
|
|
self.assertIsInstance(result, typ)
|
|
|
|
self.assertIs(result.third_arg, result["thirdArg"])
|
|
assertFoo(result.third_arg, "hello", 42)
|
|
self.assertIs(result.third_optional_arg, result["thirdOptionalArg"])
|
|
assertFoo(result.third_optional_arg, "hello-opt", 142)
|
|
|
|
self.assertIs(result.fourth_arg, result["fourthArg"])
|
|
assertFoo(result.fourth_arg["foo"], "hi", 41)
|
|
self.assertIs(result.fourth_optional_arg, result["fourthOptionalArg"])
|
|
assertFoo(result.fourth_optional_arg["foo"], "hi-opt", 141)
|
|
|
|
self.assertIs(result.fifth_arg, result["fifthArg"])
|
|
assertFoo(result.fifth_arg[0], "bye", 40)
|
|
self.assertIs(result.fifth_optional_arg, result["fifthOptionalArg"])
|
|
assertFoo(result.fifth_optional_arg[0], "bye-opt", 140)
|
|
|
|
self.assertIs(result.sixth_arg, result["sixthArg"])
|
|
assertFoo(result.sixth_arg["bar"][0], "goodbye", 39)
|
|
self.assertIs(result.sixth_optional_arg, result["sixthOptionalArg"])
|
|
assertFoo(result.sixth_optional_arg["bar"][0], "goodbye-opt", 139)
|
|
self.assertIs(result.sixth_optional_optional_arg, result["sixthOptionalOptionalArg"])
|
|
assertFoo(result.sixth_optional_optional_arg["bar"][0], "goodbye-opt-opt", 1139)
|
|
|
|
self.assertIs(result.seventh_arg, result["seventhArg"])
|
|
assertFoo(result.seventh_arg[0]["baz"], "adios", 38)
|
|
self.assertIs(result.seventh_optional_arg, result["seventhOptionalArg"])
|
|
assertFoo(result.seventh_optional_arg[0]["baz"], "adios-opt", 138)
|
|
self.assertIs(result.seventh_optional_optional_arg, result["seventhOptionalOptionalArg"])
|
|
assertFoo(result.seventh_optional_optional_arg[0]["baz"], "adios-opt-opt", 1138)
|
|
|
|
self.assertIs(result.eighth_arg, result["eighthArg"])
|
|
assertFoo(result.eighth_arg[0]["blah"][0], "farewell", 37)
|
|
self.assertIs(result.eighth_optional_arg, result["eighthOptionalArg"])
|
|
assertFoo(result.eighth_optional_arg[0]["blah"][0], "farewell-opt", 137)
|
|
self.assertIs(result.eighth_optional_optional_arg, result["eighthOptionalOptionalArg"])
|
|
assertFoo(result.eighth_optional_optional_arg[0]["blah"][0], "farewell-opt-opt", 1137)
|
|
self.assertIs(result.eighth_optional_optional_optional_arg, result["eighthOptionalOptionalOptionalArg"])
|
|
assertFoo(result.eighth_optional_optional_optional_arg[0]["blah"][0], "farewell-opt-opt-opt", 11137)
|
|
|
|
def test_nested_types_raises(self):
|
|
dict_value = {
|
|
"firstArg": "hello",
|
|
"secondArg": 42,
|
|
}
|
|
list_value = ["hello"]
|
|
|
|
tests = [
|
|
(InvalidTypeStr, dict_value),
|
|
(InvalidTypeDeclaredStr, dict_value),
|
|
(InvalidTypeOptionalStr, dict_value),
|
|
(InvalidTypeDeclaredOptionalStr, dict_value),
|
|
|
|
(InvalidTypeStr, list_value),
|
|
(InvalidTypeDeclaredStr, list_value),
|
|
(InvalidTypeOptionalStr, list_value),
|
|
(InvalidTypeDeclaredOptionalStr, list_value),
|
|
|
|
(InvalidTypeDictStr, {"foo": dict_value}),
|
|
(InvalidTypeDeclaredDictStr, {"foo": dict_value}),
|
|
(InvalidTypeOptionalDictStr, {"foo": dict_value}),
|
|
(InvalidTypeDeclaredOptionalDictStr, {"foo": dict_value}),
|
|
(InvalidTypeDictOptionalStr, {"foo": dict_value}),
|
|
(InvalidTypeDeclaredDictOptionalStr, {"foo": dict_value}),
|
|
(InvalidTypeOptionalDictOptionalStr, {"foo": dict_value}),
|
|
(InvalidTypeDeclaredOptionalDictOptionalStr, {"foo": dict_value}),
|
|
(InvalidTypeMappingStr, {"foo": dict_value}),
|
|
(InvalidTypeDeclaredMappingStr, {"foo": dict_value}),
|
|
(InvalidTypeOptionalMappingStr, {"foo": dict_value}),
|
|
(InvalidTypeDeclaredOptionalMappingStr, {"foo": dict_value}),
|
|
(InvalidTypeMappingOptionalStr, {"foo": dict_value}),
|
|
(InvalidTypeDeclaredMappingOptionalStr, {"foo": dict_value}),
|
|
(InvalidTypeOptionalMappingOptionalStr, {"foo": dict_value}),
|
|
(InvalidTypeDeclaredOptionalMappingOptionalStr, {"foo": dict_value}),
|
|
|
|
(InvalidTypeDictStr, {"foo": list_value}),
|
|
(InvalidTypeDeclaredDictStr, {"foo": list_value}),
|
|
(InvalidTypeOptionalDictStr, {"foo": list_value}),
|
|
(InvalidTypeDeclaredOptionalDictStr, {"foo": list_value}),
|
|
(InvalidTypeDictOptionalStr, {"foo": list_value}),
|
|
(InvalidTypeDeclaredDictOptionalStr, {"foo": list_value}),
|
|
(InvalidTypeOptionalDictOptionalStr, {"foo": list_value}),
|
|
(InvalidTypeDeclaredOptionalDictOptionalStr, {"foo": list_value}),
|
|
(InvalidTypeMappingStr, {"foo": list_value}),
|
|
(InvalidTypeDeclaredMappingStr, {"foo": list_value}),
|
|
(InvalidTypeOptionalMappingStr, {"foo": list_value}),
|
|
(InvalidTypeDeclaredOptionalMappingStr, {"foo": list_value}),
|
|
(InvalidTypeMappingOptionalStr, {"foo": list_value}),
|
|
(InvalidTypeDeclaredMappingOptionalStr, {"foo": list_value}),
|
|
(InvalidTypeOptionalMappingOptionalStr, {"foo": list_value}),
|
|
(InvalidTypeDeclaredOptionalMappingOptionalStr, {"foo": list_value}),
|
|
|
|
(InvalidTypeListStr, [dict_value]),
|
|
(InvalidTypeDeclaredListStr, [dict_value]),
|
|
(InvalidTypeOptionalListStr, [dict_value]),
|
|
(InvalidTypeDeclaredOptionalListStr, [dict_value]),
|
|
(InvalidTypeListOptionalStr, [dict_value]),
|
|
(InvalidTypeDeclaredListOptionalStr, [dict_value]),
|
|
(InvalidTypeOptionalListOptionalStr, [dict_value]),
|
|
(InvalidTypeDeclaredOptionalListOptionalStr, [dict_value]),
|
|
(InvalidTypeSequenceStr, [dict_value]),
|
|
(InvalidTypeDeclaredSequenceStr, [dict_value]),
|
|
(InvalidTypeOptionalSequenceStr, [dict_value]),
|
|
(InvalidTypeDeclaredOptionalSequenceStr, [dict_value]),
|
|
(InvalidTypeSequenceOptionalStr, [dict_value]),
|
|
(InvalidTypeDeclaredSequenceOptionalStr, [dict_value]),
|
|
(InvalidTypeOptionalSequenceOptionalStr, [dict_value]),
|
|
(InvalidTypeDeclaredOptionalSequenceOptionalStr, [dict_value]),
|
|
|
|
(InvalidTypeListStr, [list_value]),
|
|
(InvalidTypeDeclaredListStr, [list_value]),
|
|
(InvalidTypeOptionalListStr, [list_value]),
|
|
(InvalidTypeDeclaredOptionalListStr, [list_value]),
|
|
(InvalidTypeListOptionalStr, [list_value]),
|
|
(InvalidTypeDeclaredListOptionalStr, [list_value]),
|
|
(InvalidTypeOptionalListOptionalStr, [list_value]),
|
|
(InvalidTypeDeclaredOptionalListOptionalStr, [list_value]),
|
|
(InvalidTypeSequenceStr, [list_value]),
|
|
(InvalidTypeDeclaredSequenceStr, [list_value]),
|
|
(InvalidTypeOptionalSequenceStr, [list_value]),
|
|
(InvalidTypeDeclaredOptionalSequenceStr, [list_value]),
|
|
(InvalidTypeSequenceOptionalStr, [list_value]),
|
|
(InvalidTypeDeclaredSequenceOptionalStr, [list_value]),
|
|
(InvalidTypeOptionalSequenceOptionalStr, [list_value]),
|
|
(InvalidTypeDeclaredOptionalSequenceOptionalStr, [list_value]),
|
|
]
|
|
|
|
for typ, value in tests:
|
|
outputs = [
|
|
{"value": value},
|
|
{"value": {rpc._special_sig_key: rpc._special_secret_sig, "value": value}},
|
|
]
|
|
for output in outputs:
|
|
with self.assertRaises(AssertionError):
|
|
rpc.translate_output_properties(output, translate_output_property, typ)
|
|
|
|
def test_any(self):
|
|
output = {
|
|
"value_dict": {"hello": "world"},
|
|
"value_list": ["hello"],
|
|
"value_dict_dict": {"value": {"hello": "world"}},
|
|
"value_dict_mapping": {"value": {"hello": "world"}},
|
|
"value_list_list": [["hello"]],
|
|
"value_list_sequence": [["hello"]],
|
|
"value_str": "hello",
|
|
}
|
|
result = rpc.translate_output_properties(output, translate_output_property, OutputTypeWithAny)
|
|
self.assertIsInstance(result, OutputTypeWithAny)
|
|
self.assertEqual({"hello": "world"}, result.value_dict)
|
|
self.assertEqual(["hello"], result.value_list)
|
|
self.assertEqual({"value": {"hello": "world"}}, result.value_dict_dict)
|
|
self.assertEqual({"value": {"hello": "world"}}, result.value_dict_mapping)
|
|
self.assertEqual([["hello"]], result.value_list_list)
|
|
self.assertEqual([["hello"]], result.value_list_sequence)
|
|
self.assertEqual("hello", result.value_str)
|
|
|
|
def test_int(self):
|
|
@pulumi.output_type
|
|
class OutputTypeWithInt(dict):
|
|
value_dict: Dict[str, int]
|
|
value_mapping: Mapping[str, int]
|
|
value_list: List[int]
|
|
value_sequence: Sequence[int]
|
|
value_int: int
|
|
|
|
output = {
|
|
"value_dict": {"hello": 42.0},
|
|
"value_mapping": {"world": 100.0},
|
|
"value_list": [42.0],
|
|
"value_sequence": [100.0],
|
|
"value_int": 50.0,
|
|
}
|
|
|
|
result = rpc.translate_output_properties(output, translate_output_property, OutputTypeWithInt)
|
|
|
|
self.assertIsInstance(result, OutputTypeWithInt)
|
|
self.assertEqual({"hello": 42}, result.value_dict)
|
|
self.assertIsInstance(result.value_dict["hello"], int)
|
|
self.assertEqual({"world": 100}, result.value_mapping)
|
|
self.assertIsInstance(result.value_mapping["world"], int)
|
|
self.assertEqual([42], result.value_list)
|
|
self.assertIsInstance(result.value_list[0], int)
|
|
self.assertEqual([100], result.value_sequence)
|
|
self.assertIsInstance(result.value_sequence[0], int)
|
|
self.assertEqual(50, result.value_int)
|
|
self.assertIsInstance(result.value_int, int)
|
|
|
|
def test_individual_values(self):
|
|
@pulumi.output_type
|
|
class MyOutput:
|
|
first_arg: str = pulumi.property("firstArg")
|
|
second_arg: int = pulumi.property("secondArg")
|
|
|
|
def __init__(self, first_arg: str, second_arg: int):
|
|
pulumi.set(self, "first_arg", first_arg)
|
|
pulumi.set(self, "second_arg", second_arg)
|
|
|
|
def _translate_property(self, prop: str) -> str:
|
|
return camel_case_to_snake_case.get(prop) or prop
|
|
|
|
class TestCase(NamedTuple):
|
|
output: Any
|
|
typ: type
|
|
expected: Any
|
|
|
|
testcases = [
|
|
TestCase(
|
|
{
|
|
"firstArg": "hello",
|
|
"secondArg": 42,
|
|
},
|
|
MyOutput,
|
|
MyOutput("hello", 42),
|
|
),
|
|
TestCase(
|
|
{
|
|
"foo": {
|
|
"firstArg": "hi",
|
|
"secondArg": 41,
|
|
},
|
|
},
|
|
Mapping[str, MyOutput],
|
|
{
|
|
"foo": MyOutput("hi", 41),
|
|
},
|
|
),
|
|
TestCase(
|
|
[{
|
|
"firstArg": "bye",
|
|
"secondArg": 40,
|
|
}],
|
|
Sequence[MyOutput],
|
|
[MyOutput("bye", 40)],
|
|
),
|
|
TestCase(
|
|
{
|
|
"bar": [{
|
|
"firstArg": "goodbye",
|
|
"secondArg": 39,
|
|
}],
|
|
},
|
|
Mapping[str, Sequence[MyOutput]],
|
|
{
|
|
"bar": [MyOutput("goodbye", 39)],
|
|
}
|
|
),
|
|
TestCase(
|
|
[{
|
|
"baz": {
|
|
"firstArg": "adios",
|
|
"secondArg": 38,
|
|
},
|
|
}],
|
|
Sequence[Mapping[str, MyOutput]],
|
|
[{
|
|
"baz": MyOutput("adios", 38),
|
|
}]
|
|
),
|
|
TestCase(
|
|
[{
|
|
"blah": [{
|
|
"firstArg": "farewell",
|
|
"secondArg": 37,
|
|
}],
|
|
}],
|
|
Sequence[Mapping[str, Sequence[MyOutput]]],
|
|
[{
|
|
"blah": [MyOutput("farewell", 37)],
|
|
}],
|
|
),
|
|
]
|
|
|
|
for case in testcases:
|
|
actual = rpc.translate_output_properties(case.output, translate_output_property, case.typ)
|
|
self.assertEqual(case.expected, actual)
|
|
|
|
for case in testcases:
|
|
wrapped_output = {rpc._special_sig_key: rpc._special_secret_sig, "value": case.output}
|
|
actual = rpc.translate_output_properties(wrapped_output, translate_output_property, case.typ)
|
|
wrapped_expected = {rpc._special_sig_key: rpc. _special_secret_sig, "value": case.expected}
|
|
self.assertEqual(wrapped_expected, actual)
|