def test_serialize_handles_escapes(self):
cv = types.String()
result = cv.serialize("a\n\tb")
assert isinstance(result, str)
assert result == r"a\n\tb"
def test_deserialize_enforces_choices(self):
cv = types.String(choices=["foo", "bar", "baz"])
assert cv.deserialize(b"foo") == "foo"
with pytest.raises(ValueError):
cv.deserialize(b"foobar")
def test_serialize_none(self):
cv = types.String()
result = cv.serialize(None)
assert isinstance(result, str)
assert result == ""
def test_deserialize_enforces_choices_optional(self):
cv = types.String(optional=True, choices=["foo", "bar", "baz"])
assert cv.deserialize(b"") is None
with pytest.raises(ValueError):
cv.deserialize(b"foobar")
def test_serialize_returns_text(self):
cv = types.String()
result = cv.serialize("æøå")
assert isinstance(result, str)
assert result == "æøå"
def test_deserialize_conversion_success(self):
cv = types.String()
result = cv.deserialize(b" foo ")
assert result == "foo"
assert isinstance(result, str)
def test_deserialize_choice_values():
expected = collections.OrderedDict([("a", "1"), ("b", "2"), ("c", "3")])
type = ConfigMap(values=types.String(choices=["1", "2", "3"]))
assert type.deserialize("a|1, b|2 , c|3") == expected
assert type.deserialize("a|1\n b|2 \nc|3") == expected
with pytest.raises(ValueError):
type.deserialize("x|0")
def test_serialize_decodes_bytes(self):
cv = types.String()
bytes_string = "æøå".encode()
result = cv.serialize(bytes_string)
assert isinstance(result, str)
assert result == bytes_string.decode()
def test_deserialize_decode_failure(self):
value = types.String()
incorrectly_encoded_bytes = u'æøå'.encode('iso-8859-1')
self.assertRaises(ValueError, value.deserialize,
incorrectly_encoded_bytes)
def test_deserialize_respects_optional(self):
value = types.String(optional=True)
self.assertIsNone(value.deserialize(b''))
self.assertIsNone(value.deserialize(b' '))
def test_deserialize_enforces_required(self):
value = types.String()
self.assertRaises(ValueError, value.deserialize, b'')
def test_deserialize_enforces_choices(self):
value = types.String(choices=['foo', 'bar', 'baz'])
self.assertEqual('foo', value.deserialize(b'foo'))
self.assertRaises(ValueError, value.deserialize, b'foobar')
def test_deserialize_handles_escapes(self):
value = types.String(optional=True)
result = value.deserialize(b'a\\t\\nb')
self.assertEqual('a\t\nb', result)
def test_deserialize_respects_optional(self):
cv = types.String(optional=True)
assert cv.deserialize(b"") is None
assert cv.deserialize(b" ") is None
def test_serialize_none():
type = ConfigMap(keys=types.String(), values=types.Integer())
result = type.serialize(None)
assert result == ""
def test_deserialize_conversion_success(self):
value = types.String()
self.assertEqual('foo', value.deserialize(b' foo '))
self.assertIsInstance(value.deserialize(b'foo'), unicode)
def test_deserialize_decodes_utf8(self):
cv = types.String()
result = cv.deserialize("æøå".encode())
assert result == "æøå"
def test_deserialize_optional_values():
expected = collections.OrderedDict([("a", "1"), ("b", None), ("c", None)])
type = ConfigMap(values=types.String(optional=True))
assert type.deserialize("a|1, b| , c") == expected
assert type.deserialize("a|1\n b| \nc") == expected
def test_deserialize_does_not_double_encode_unicode(self):
cv = types.String()
result = cv.deserialize("æøå")
assert result == "æøå"
def test_deserialize_handles_escapes(self):
cv = types.String(optional=True)
result = cv.deserialize(b"a\\t\\nb")
assert result == "a\t\nb"
def test_deserialize_enforces_required(self):
cv = types.String()
with pytest.raises(ValueError):
cv.deserialize(b"")
def test_serialize_does_not_encode_bytes(self):
value = types.String()
result = value.serialize('æøå'.encode('utf-8'))
self.assertIsInstance(result, bytes)
self.assertEqual('æøå'.encode('utf-8'), result)
def test_deserialize_decodes_utf8(self):
value = types.String()
result = value.deserialize('æøå'.encode('utf-8'))
self.assertEqual('æøå', result)
def test_serialize_handles_escapes(self):
value = types.String()
result = value.serialize('a\n\tb')
self.assertIsInstance(result, bytes)
self.assertEqual(r'a\n\tb'.encode('utf-8'), result)
def test_deserialize_does_not_double_encode_unicode(self):
value = types.String()
result = value.deserialize('æøå')
self.assertEqual('æøå', result)
def test_serialize_none(self):
value = types.String()
result = value.serialize(None)
self.assertIsInstance(result, bytes)
self.assertEqual(b'', result)
def test_deserialize_invalid_encoding(self):
cv = types.String()
incorrectly_encoded_bytes = "æøå".encode("iso-8859-1")
assert cv.deserialize(incorrectly_encoded_bytes) == "\udce6\udcf8\udce5"
def test_serialize():
type = ConfigMap(keys=types.String(), values=types.Integer())
value = collections.OrderedDict([("a", 1), ("b", 2), ("c", 3)])
result = type.serialize(value)
assert re.match(r"\s*a|1\n\s*b|2\n\s*c|3", result)
def test_deserialize_enforces_choices_optional(self):
value = types.String(optional=True, choices=['foo', 'bar', 'baz'])
self.assertEqual(None, value.deserialize(b''))
self.assertRaises(ValueError, value.deserialize, b'foobar')
