def test_references(self):
reference_1 = TypeWithStrRenderingSymbolReference('symbol_1_name', is_any_type_w_str_rendering())
reference_2 = TypeWithStrRenderingSymbolReference('symbol_2_name', OrReferenceRestrictions([]))
cases = [
(
'no elements',
sut.ListSdv([]),
asrt.is_empty_sequence,
),
(
'single string constant element',
sut.ListSdv([list_sdvs.str_element('string value')]),
asrt.is_empty_sequence,
),
(
'multiple elements with multiple references',
sut.ListSdv([
list_sdvs.symbol_element(reference_1.reference),
list_sdvs.str_element('constant value'),
list_sdvs.symbol_element(reference_2.reference),
]),
asrt.matches_sequence([
reference_1.reference_assertion,
reference_2.reference_assertion,
]),
),
]
for test_name, list_sdv, expected_references_assertion in cases:
with self.subTest(test_name=test_name):
actual = list_sdv.references
expected_references_assertion.apply_without_message(self, actual)
def test_resolve_with_concatenation_of_referenced_list_symbols(self):
empty_list_symbol = ListDdvSymbolContext('empty_list_symbol', ListDdv([]))
multi_element_list_symbol = ListDdvSymbolContext(
'multi_element_list_symbol',
ListDdv(
[string_ddv_of_single_string('multi list element 1'),
string_ddv_of_single_string('multi list element 2')])
)
cases = [
Case(
'WHEN list is a single symbol reference AND symbol is an empty list '
'THEN resolved value'
'SHOULD be an empty list',
sdv_to_check=
sut.ListSdv([list_sdvs.symbol_element(empty_list_symbol.reference__w_str_rendering)]),
symbols=
empty_list_symbol.symbol_table,
expected_resolved_value=
empty_list_symbol.ddv,
),
Case(
'WHEN list is a single symbol reference AND symbol is a non-empty list '
'THEN resolved value'
'SHOULD be equal to the non-empty list',
sdv_to_check=
sut.ListSdv([list_sdvs.symbol_element(multi_element_list_symbol.reference__w_str_rendering)]),
symbols=
multi_element_list_symbol.symbol_table,
expected_resolved_value=
multi_element_list_symbol.ddv,
),
Case(
'WHEN list is multiple symbol reference AND all symbols are lists'
'THEN resolved value'
'SHOULD be equal to the concatenation of referenced lists',
sdv_to_check=
sut.ListSdv([list_sdvs.symbol_element(multi_element_list_symbol.reference__w_str_rendering),
list_sdvs.symbol_element(empty_list_symbol.reference__w_str_rendering),
list_sdvs.symbol_element(multi_element_list_symbol.reference__w_str_rendering)]),
symbols=
SymbolContext.symbol_table_of_contexts([
multi_element_list_symbol,
empty_list_symbol,
]),
expected_resolved_value=
ListDdv(list(list(multi_element_list_symbol.ddv.string_elements) +
list(multi_element_list_symbol.ddv.string_elements))),
),
]
self._check('concatenation of referenced list symbols', cases)
def test_resolve_without_symbol_references(self):
string_constant_1 = 'string constant 1'
string_constant_2 = 'string constant 2'
string_symbol = StringConstantSymbolContext('string_symbol_name', 'string symbol value')
cases = [
Case(
'no elements',
sdv_to_check=
sut.ListSdv([]),
symbols=
empty_symbol_table(),
expected_resolved_value=
ListDdv([]),
),
Case(
'single constant element',
sdv_to_check=
sut.ListSdv([list_sdvs.str_element(string_constant_1)]),
symbols=
empty_symbol_table(),
expected_resolved_value=
ListDdv([string_ddv_of_single_string(string_constant_1)]),
),
Case(
'multiple constant elements',
sdv_to_check=
sut.ListSdv([list_sdvs.str_element(string_constant_1),
list_sdvs.str_element(string_constant_2)]),
symbols=
empty_symbol_table(),
expected_resolved_value=
ListDdv([string_ddv_of_single_string(string_constant_1),
string_ddv_of_single_string(string_constant_2)]),
),
Case(
'single string symbol reference element',
sdv_to_check=
sut.ListSdv([list_sdvs.symbol_element(string_symbol.reference__w_str_rendering)]),
symbols=
string_symbol.symbol_table,
expected_resolved_value=
ListDdv([string_ddv_of_single_string(string_symbol.str_value)]),
),
]
self._check('resolve without symbol references', cases)
def test_reference_to_symbol_that_are_not_lists(self):
string_symbol_str = 'string constant'
string_symbol = StringConstantSymbolContext('string_symbol',
string_symbol_str)
path_symbol = arbitrary_path_symbol_context('path_symbol')
cases = [
Case(
'reference to string symbol',
sdv_to_check=
sut.ListSdv([list_sdvs.symbol_element(string_symbol.reference__w_str_rendering)]),
symbols=
string_symbol.symbol_table,
expected_resolved_value=
ListDdv([string_ddv_of_single_string(string_symbol.str_value)]),
),
Case(
'reference to path symbol '
'SHOULD resolve to string representation of the path value',
sdv_to_check=
sut.ListSdv([list_sdvs.symbol_element(path_symbol.reference__w_str_rendering)]),
symbols=
path_symbol.symbol_table,
expected_resolved_value=
ListDdv([string_ddv_of_single_path(path_symbol.ddv)]),
),
Case(
'combination of string and path value',
sdv_to_check=
sut.ListSdv([list_sdvs.symbol_element(string_symbol.reference__w_str_rendering),
list_sdvs.symbol_element(path_symbol.reference__w_str_rendering)]),
symbols=
SymbolContext.symbol_table_of_contexts([
string_symbol,
path_symbol,
]),
expected_resolved_value=
ListDdv([string_ddv_of_single_string(string_symbol.str_value),
string_ddv_of_single_path(path_symbol.ddv)]),
),
]
self._check('reference to symbol that are not lists', cases)
def test_elements(self):
# ARRANGE #
element_1 = list_sdvs.str_element('constant value')
element_2 = list_sdvs.symbol_element(
data_references.reference_to__on_direct_and_indirect('symbol_name'))
sdv = sut.ListSdv([element_1, element_2])
# ACT #
actual = sdv.elements
# ASSERT #
assertion = asrt.matches_sequence([equals_list_sdv_element(element_1),
equals_list_sdv_element(element_2)])
assertion.apply_without_message(self, actual)
def sdv_with_single_constant_fragment(element_value: str) -> sut.ListSdv:
return sut.ListSdv([string_ddv_of_single_string(element_value)])
def check_elements(put: unittest.TestCase, expected_elements: List[ElementSdv],
actual: lr.ListSdv):
expected = lr.ListSdv(expected_elements)
assertion = equals_list_sdv(expected)
assertion.apply_with_message(put, actual, 'list sdv')