def transmute_to_and_from_with_excluded_items(self):
class MixedMappedModel(JsonMappedModel):
__mapping__ = {
'test': Attr('test', int),
'another': Attr('another', int, serialize=False)
}
mapping = MixedMappedModel()
mapping.test = 1
mapping.another = 2
without_result = '{"test": 1}'
result_without = JsonTransmuter.transmute_to(mapping)
expect(result_without).to.equal(without_result)
# Make sure we can override the serialization preferences
result_with = JsonTransmuter.transmute_to(
mapping,
to_string=False,
serialize_all=True
)
expect(result_with.get('test')).to.equal(1)
expect(result_with.get('another')).to.equal(2)
result = JsonTransmuter.transmute_from(
{'test': 100, 'another': 200},
MixedMappedModel
)
expect(result.test).to.equal(100)
expect(result.another).to.equal(200)
def transmute_from_with_inherited_mapping(self):
data = '{"test": "sample", "second": "other"}'
result = JsonTransmuter.transmute_from(data, TestExtendedModel)
expect(result.test).to.equal('sample')
expect(result.second).to.equal('other')
def transmute_from_with_child_mapping(self):
data = '{"other": "sample", "child": {"test": "sample stuff"}}'
result = JsonTransmuter.transmute_from(data, TestChildMapping)
require(result.child).not_to.be_none()
expect(result.child.test).to.equal('sample stuff')
def deserialize(self, raw_config, config_cls):
import yaml
config_dict = yaml.load(raw_config)
for k in config_dict.keys():
config_dict[k] = os.environ.get(k.upper()) or config_dict[k]
return JsonTransmuter.transmute_from(config_dict, config_cls)
def transmute_from_with_list_of_child_mappings(self):
data = '{"children": [{"test": "sample1"}, {"test": "sample2"}]}'
result = JsonTransmuter.transmute_from(data, TestListChildMapping)
require(result.children).not_to.be_none()
expect(len(result.children)).to.equal(2)
expect(result.children[0].test).to.equal('sample1')
expect(result.children[1].test).to.equal('sample2')
def transmute_to_with_old_attr_style(self):
class OldStyleMappedModel(JsonMappedModel):
__mapping__ = {
'test': ['test', int]
}
mapping = OldStyleMappedModel()
mapping.test = 0
expected_result = '{"test": 0}'
result = JsonTransmuter.transmute_to(mapping)
expect(result).to.equal(expected_result)
result = JsonTransmuter.transmute_from(
{'test': 1},
OldStyleMappedModel
)
expect(result.test).to.equal(1)
def transmute_attribute_with_type(self, attr_type, attr_data,
attr_result):
class FlexMapping(JsonMappedModel):
__mapping__ = {
'test': Attr('test', attr_type)
}
data = '{{"test": {0} }}'.format(attr_data)
result = JsonTransmuter.transmute_from(data, FlexMapping)
expect(result.test).to.equal(attr_result)
def transmute_to_with_child_mapping(self):
child_mapping = TestMappedModel()
child_mapping.test = 'sample stuff'
mapping = TestChildMapping()
mapping.child = child_mapping
expected_result = '{"child": {"test": "sample stuff"}}'
result = JsonTransmuter.transmute_to(mapping)
expect(result).to.equal(expected_result)
def transmute_to_with_list_of_child_mappings(self):
child_mapping = TestMappedModel()
child_mapping.test = 'sample stuff'
mapping = TestListChildMapping()
mapping.children = [child_mapping]
expected_result = '{"children": [{"test": "sample stuff"}]}'
result = JsonTransmuter.transmute_to(mapping)
expect(result).to.equal(expected_result)
def transmute_to_with_inherited_mapping(self):
model = TestExtendedModel()
model.test = 'sample'
model.second = 'other'
expected_result = json.loads('{"test": "sample", "second": "other"}')
result = JsonTransmuter.transmute_to(model)
result_dict = json.loads(result)
expect(result_dict['test']).to.equal(expected_result['test'])
expect(result_dict['second']).to.equal(expected_result['second'])
def transmute_to_with_null_value(self):
mapping = TestMappedModel()
mapping.test = None
expected_result = '{"test": null}'
result = JsonTransmuter.transmute_to(
mapping,
assign_all=True,
coerce_values=False
)
expect(result).to.equal(expected_result)
def transmute_attribute_with_type(self, attr_type, attr_data,
attr_result):
class FlexMapping(JsonMappedModel):
__mapping__ = {
'test': ['test', attr_type]
}
mapping = FlexMapping()
mapping.test = attr_result
result = JsonTransmuter.transmute_to(mapping)
expected_result = '{{"test": {0}}}'.format(attr_data)
expect(result).to.equal(expected_result)
def transmute_to_with_zero_int_value(self):
class IntMappedModel(JsonMappedModel):
__mapping__ = {
'test': Attr('test', int)
}
mapping = IntMappedModel()
mapping.test = 0
expected_result = '{"test": 0}'
result = JsonTransmuter.transmute_to(mapping)
expect(result).to.equal(expected_result)
def transmute_to_coerce_decimal_to_int(self):
import decimal
class IntMappedModel(JsonMappedModel):
__mapping__ = {
'test': Attr('test', int)
}
mapping = IntMappedModel()
mapping.test = decimal.Decimal(10)
expected_result = '{"test": 10}'
result = JsonTransmuter.transmute_to(mapping)
expect(result).to.equal(expected_result)
def deserialize(self, raw_config, config_cls):
config_dict = self.parse(raw_config)
return JsonTransmuter.transmute_from(config_dict, config_cls)
def serialize(self, config):
return JsonTransmuter.transmute_to(config, to_string=False)
def deserialize(self, raw_config, config_cls):
return JsonTransmuter.transmute_from(raw_config, config_cls)
def serialize(self, config):
return JsonTransmuter.transmute_to(config).encode('utf-8')
def deserialize(self, raw_config, config_cls):
return JsonTransmuter.transmute_from(raw_config.decode('utf-8'),
config_cls)
def serialize(self, config):
import yaml
config_dict = JsonTransmuter.transmute_to(config, to_string=False)
return yaml.dump(config_dict).encode('utf-8')
def deserialize(self, raw_config, config_cls):
import yaml
config_dict = yaml.load(raw_config)
return JsonTransmuter.transmute_from(config_dict, config_cls)
