def test_regular_dataclass_as_dict(self):
dc = RegularDataclass('A', 1)
self.assertEqual(asdict(dc), {
'first': 'A',
'second': 1,
'third': False
})
def convert_element(self, element: Any) -> str:
if dataclasses.is_dataclass(type(element)):
element = asdict(element)
try:
return yaml.dump(element, sort_keys=False)
except yaml.YAMLError as e:
raise BadFormatError(f'Failed to convert to YAML: {e}') from e
def convert_element(self, element: Any) -> str:
if dataclasses.is_dataclass(type(element)):
element = asdict(element)
try:
return json.dumps(element, indent=2)
except json.JSONDecodeError as e:
raise BadFormatError(f'Failed to convert to JSON: {e}') from e
def test_as_dict_on_nested_recorded_dataclass(self):
dc = DataclassWithNestedRecordedDataclass(RecordedDataclass('A', 1))
self.assertEqual(asdict(dc), {
'the_dc': {
'first': 'A',
'second': 1
}
})
dc.the_dc.third = True
self.assertEqual(asdict(dc), {
'the_dc': {
'first': 'A',
'second': 1,
'third': True
}
})
def test_as_dict_on_dict_of_recorded_dataclass(self):
dc = DataclassWithDict({'A': RecordedDataclass('A', 1), 'B': RecordedDataclass('B', 2, third=True)})
self.assertEqual(asdict(dc), {
'the_dict': {
'A': {'first': 'A', 'second': 1},
'B': {'first': 'B', 'second': 2, 'third': True}
}
})
def test_as_dict_on_tuple_of_recorded_dataclass(self):
dc = DataclassWithTupleOfDataclass((RecordedDataclass('A', 1), RecordedDataclass('B', 2, third=True)))
self.assertEqual(asdict(dc), {
'the_tuple': (
{'first': 'A', 'second': 1},
{'first': 'B', 'second': 2, 'third': True}
)
})
def test_as_dict_on_list_of_recorded_dataclass(self):
dc = DataclassWithList([RecordedDataclass('A', 1), RecordedDataclass('B', 2, third=True)])
self.assertEqual(asdict(dc), {
'the_list': [
{'first': 'A', 'second': 1},
{'first': 'B', 'second': 2, 'third': True}
]
})
def test_as_dict_on_nested_regular_dataclass(self):
dc = DataclassWithNestedRegularDataclass(RegularDataclass('A', 1))
self.assertEqual(asdict(dc), {
'the_dc': {
'first': 'A',
'second': 1,
'third': False
}
})
def convert_list(self, element_list: List[Any]) -> str:
converted_element_list = []
for e in element_list:
if dataclasses.is_dataclass(type(e)):
converted_element_list.append(asdict(e))
else:
converted_element_list.append(e)
data = {'items': converted_element_list}
try:
return yaml.dump(data, sort_keys=False)
except yaml.YAMLError as e:
raise BadFormatError(f'Failed to convert to YAML: {e}') from e
def convert_list(self, element_list: List[Any]) -> str:
converted_element_list = []
for e in element_list:
if dataclasses.is_dataclass(type(e)):
converted_element_list.append(asdict(e))
else:
converted_element_list.append(e)
data = {'items': converted_element_list}
try:
return json.dumps(data, indent=2)
except json.JSONDecodeError as e:
raise BadFormatError(f'Failed to convert to JSON: {e}') from e
def config_to_dict(self, config: Config) -> Dict:
as_dict = asdict(config)
self.__strip_names(as_dict)
return as_dict
def raw_environments(self):
raw = {}
for k, v in self.environments.items():
raw[k] = asdict(v)
return raw
def test_recorded_dataclass_as_dict(self):
dc = RecordedDataclass('A', 1)
self.assertEqual(asdict(dc), {
'first': 'A',
'second': 1
})
def test_as_dict_on_list(self):
dc = DataclassWithList(['A', 'B', 'C'])
self.assertEqual(asdict(dc), {
'the_list': ['A', 'B', 'C']
})
self.assertTrue(id(dc.the_list) != id(asdict(dc)['the_list']))
def test_as_dict_on_named_tuple(self):
dc = DataclassWithNamedTuple(point=Point(11, 22))
self.assertEqual(asdict(dc), {
'point': Point(11, 22)
})
def test_as_dict_on_dict_not_set(self):
dc = DataclassWithDict()
self.assertEqual(asdict(dc), {})
def test_as_dict_on_dict(self):
dc = DataclassWithDict({'A': 'test1', 'B': 'test2'})
self.assertEqual(asdict(dc), {
'the_dict': {'A': 'test1', 'B': 'test2'}
})
self.assertTrue(id(dc.the_dict) != id(asdict(dc)['the_dict']))
def test_as_dict_on_tuple(self):
dc = DataclassWithTuple(('A', 'B', 'C'))
self.assertEqual(asdict(dc), {
'the_tuple': ('A', 'B', 'C')
})
self.assertTrue(id(dc.the_tuple) != id(asdict(dc)['the_tuple']))
