def __init__(self, expected: ListDdv):
super().__init__(ListDdv, expected)
self._expected = expected
self._sequence_of_element_assertions = []
for idx, element in enumerate(expected.string_elements):
assert isinstance(
element, StringDdv), 'Element must be a StringDdv #' + str(idx)
self._sequence_of_element_assertions.append(
asrt_sv.equals_string_ddv(element))
def test_pass(self):
cases = [
(
'no fragments',
sut.StringDdv(tuple([])),
),
(
'single fragment',
sut.StringDdv(tuple([csv.ConstantFragmentDdv('fragment value')])),
),
]
for name, value in cases:
with self.subTest(name=name):
assertion = sut.equals_string_ddv(value)
assertion.apply_without_message(self, value)
def equals_string_sdv(expected: StringSdv,
symbols: SymbolTable = None) -> Assertion[SymbolDependentValue]:
if symbols is None:
symbols = symbol_table_with_values_matching_references(expected.references)
expected_resolved_value = expected.resolve(symbols)
def get_fragment_sdvs(x: StringSdv) -> Sequence[StringFragmentSdv]:
return x.fragments
return type_sdv_assertions.matches_sdv_of_string(
equals_symbol_references__w_str_rendering(expected.references),
equals_string_ddv(expected_resolved_value),
asrt.sub_component('fragment resolvers',
get_fragment_sdvs,
equals_string_fragments(
expected.fragments)),
symbols)
def equals_list_sdv_element(expected: list_sdv.ElementSdv,
symbols: SymbolTable = None) -> Assertion[list_sdv.ElementSdv]:
if symbols is None:
symbols = symbol_table_with_values_matching_references(list(expected.references))
expected_resolved_value_list = expected.resolve(symbols)
assertion_on_resolved_value = asrt.matches_sequence(
[equals_string_ddv(sv) for sv in expected_resolved_value_list])
component_assertions = [
asrt.sub_component('references',
lambda x: list(x.references),
equals_symbol_references__w_str_rendering(list(expected.references))),
asrt.sub_component('resolved value',
lambda x: x.resolve(symbols),
assertion_on_resolved_value),
]
symbol_reference_assertion = asrt.is_none
reference = expected.symbol_reference_if_is_symbol_reference
if reference is not None:
reference_restrictions = reference.restrictions
if not isinstance(reference_restrictions, WithStrRenderingTypeRestrictions):
raise ValueError('A list element must reference a data type value')
assert isinstance(reference_restrictions, WithStrRenderingTypeRestrictions) # Type info for IDE
symbol_reference_assertion = equals_data_type_symbol_reference(reference)
asrt_sym_ref.matches_reference_2(
reference.name,
data_restrictions_assertions.equals__w_str_rendering(
reference_restrictions)
)
symbol_reference_component_assertion = asrt.sub_component('symbol_reference_if_is_symbol_reference',
lambda x: x.symbol_reference_if_is_symbol_reference,
symbol_reference_assertion)
component_assertions.append(symbol_reference_component_assertion)
return asrt.is_instance_with(
list_sdv.ElementSdv,
asrt.and_(component_assertions))
def test_resolve(self):
string_constant_1 = 'string constant 1'
string_constant_2 = 'string constant 2'
string_symbol = StringConstantSymbolContext('string_symbol_name',
'string symbol value')
path_symbol = ConstantSuffixPathDdvSymbolContext(
'path_symbol_name', RelOptionType.REL_ACT, 'file-name')
list_symbol = ListConstantSymbolContext(
'list_symbol_name', ['list element 1', 'list element 2'])
cases = [
(
'no fragments',
sut.StringSdv(()),
empty_symbol_table(),
csv.StringDdv(()),
),
(
'single string constant fragment',
sut.StringSdv(
(impl.ConstantStringFragmentSdv(string_constant_1), )),
empty_symbol_table(),
csv.StringDdv((csv.ConstantFragmentDdv(string_constant_1), )),
),
(
'multiple single string constant fragments',
sut.StringSdv(
(impl.ConstantStringFragmentSdv(string_constant_1),
impl.ConstantStringFragmentSdv(string_constant_2))),
empty_symbol_table(),
csv.StringDdv((csv.ConstantFragmentDdv(string_constant_1),
csv.ConstantFragmentDdv(string_constant_2))),
),
(
'single symbol fragment/symbol is a string',
sut.StringSdv((impl.SymbolStringFragmentSdv(
string_symbol.reference__w_str_rendering), )),
string_symbol.symbol_table,
csv.StringDdv(
(csv.ConstantFragmentDdv(string_symbol.str_value), )),
),
(
'single symbol fragment/symbol is a path',
sut.StringSdv((impl.SymbolStringFragmentSdv(
path_symbol.reference__w_str_rendering), )),
path_symbol.symbol_table,
csv.StringDdv((csv.PathFragmentDdv(path_symbol.ddv), )),
),
(
'single symbol fragment/symbol is a list',
sut.StringSdv((impl.SymbolStringFragmentSdv(
list_symbol.reference__w_str_rendering), )),
list_symbol.symbol_table,
csv.StringDdv((csv.ListFragmentDdv(list_symbol.ddv), )),
),
(
'multiple fragments of different types',
sut.StringSdv((
impl.SymbolStringFragmentSdv(
string_symbol.reference__w_str_rendering),
impl.ConstantStringFragmentSdv(string_constant_1),
impl.SymbolStringFragmentSdv(
path_symbol.reference__w_str_rendering),
impl.SymbolStringFragmentSdv(
list_symbol.reference__w_str_rendering),
)),
SymbolContext.symbol_table_of_contexts([
string_symbol,
path_symbol,
list_symbol,
]),
csv.StringDdv((
csv.ConstantFragmentDdv(string_symbol.str_value),
csv.ConstantFragmentDdv(string_constant_1),
csv.PathFragmentDdv(path_symbol.ddv),
csv.ListFragmentDdv(list_symbol.ddv),
)),
),
]
for test_name, string_value, symbol_table, expected in cases:
with self.subTest(test_name=test_name):
actual = string_value.resolve(symbol_table)
assertion = equals_string_ddv(expected)
assertion.apply_without_message(self, actual)
def test_fail__different_fragment_value(self):
actual = sut.StringDdv(tuple([csv.ConstantFragmentDdv('actual fragment value')]))
expected = sut.StringDdv(tuple([csv.ConstantFragmentDdv('expected fragment value')]))
assertion = sut.equals_string_ddv(expected)
assert_that_assertion_fails(assertion, actual)