more support for bytearray

Author: samuelcolvin

src/input/input_python.rs

@@ -3,8 +3,8 @@ use std::str::from_utf8;
 use pyo3::exceptions::{PyAttributeError, PyTypeError};
 use pyo3::prelude::*;
 use pyo3::types::{
-    PyBool, PyBytes, PyDate, PyDateTime, PyDict, PyFrozenSet, PyInt, PyList, PyMapping, PySequence, PySet, PyString,
-    PyTime, PyTuple, PyType,
+    PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFrozenSet, PyInt, PyList, PyMapping, PySequence, PySet,
+    PyString, PyTime, PyTuple, PyType,
 };
 use pyo3::{intern, AsPyPointer};
 
@@ -60,6 +60,12 @@ impl<'a> Input<'a> for PyAny {
                 Err(_) => return Err(ValError::new(ErrorKind::StrUnicode, self)),
             };
             Ok(str.into())
+        } else if let Ok(py_byte_array) = self.cast_as::<PyByteArray>() {
+            let str = match from_utf8(unsafe { py_byte_array.as_bytes() }) {
+                Ok(s) => s,
+                Err(_) => return Err(ValError::new(ErrorKind::StrUnicode, self)),
+            };
+            Ok(str.into())
         } else if self.cast_as::<PyBool>().is_ok() {
             // do this before int and float parsing as `False` is cast to `0` and we don't want False to
             // be returned as a string
@@ -270,6 +276,8 @@ impl<'a> Input<'a> for PyAny {
         } else if let Ok(py_str) = self.cast_as::<PyString>() {
             let string = py_str.to_string_lossy().to_string();
             Ok(string.into_bytes().into())
+        } else if let Ok(py_byte_array) = self.cast_as::<PyByteArray>() {
+            Ok(py_byte_array.to_vec().into())
         } else {
             Err(ValError::new(ErrorKind::BytesType, self))
         }

tests/validators/test_bytes.py

@@ -14,14 +14,17 @@ def test_strict_bytes_validator():
     assert v.validate_json('"foo"') == b'foo'
 
     with pytest.raises(ValidationError, match='Value must be a valid bytes'):
-        assert v.validate_python('foo') == b'foo'
+        v.validate_python('foo')
+    with pytest.raises(ValidationError, match='Value must be a valid bytes'):
+        v.validate_python(bytearray(b'foo'))
 
 
 def test_lax_bytes_validator():
     v = SchemaValidator({'type': 'bytes'})
 
     assert v.validate_python(b'foo') == b'foo'
     assert v.validate_python('foo') == b'foo'
+    assert v.validate_python(bytearray(b'foo')) == b'foo'
 
     assert v.validate_json('"foo"') == b'foo'
 

tests/validators/test_string.py

@@ -41,7 +41,12 @@ def test_str(py_or_json, input_value, expected):
     [
         ('foobar', 'foobar'),
         (b'foobar', 'foobar'),
+        (bytearray(b'foobar'), 'foobar'),
         (b'\x81', Err('Value must be a valid string, unable to parse raw data as a unicode string [kind=str_unicode')),
+        (
+            bytearray(b'\x81'),
+            Err('Value must be a valid string, unable to parse raw data as a unicode string [kind=str_unicode'),
+        ),
         # null bytes are very annoying, but we can't really block them here
         (b'\x00', '\x00'),
         (123, '123'),