Added validator tests.

These are currently pytest-style tests. Install pytest and run with:
~> pytest _plotly_utils/tests/

Author: Jon M. Mease

Diff for: .gitignore

@@ -32,3 +32,5 @@ js/node_modules/
 
 # Compiled javascript
 plotlywidget/static/
+
+.pytest_cache

Diff for: _plotly_utils/tests/resources/1x1-black.png

@@ -0,0 +1,40 @@
+import pytest
+from _plotly_utils.basevalidators import AngleValidator
+import numpy as np
+
+
+# Fixtures
+# --------
+@pytest.fixture()
+def validator():
+    return AngleValidator('prop', 'parent')
+
+
+# Tests
+# -----
+# ### Test acceptance ###
+@pytest.mark.parametrize('val', [0] + list(np.linspace(-180, 179.99)))
+def test_acceptance(val, validator):
+    assert validator.validate_coerce(val) == val
+
+
+# ### Test coercion above 180 ###
+@pytest.mark.parametrize('val,expected', [
+    (180, -180),
+    (181, -179),
+    (-180.25, 179.75),
+    (540, -180),
+    (-541, 179)
+])
+def test_coercion(val, expected, validator):
+    assert validator.validate_coerce(val) == expected
+
+
+# ### Test rejection ###
+@pytest.mark.parametrize('val',
+                         ['hello', (), [], [1, 2, 3], set(), '34'])
+def test_rejection(val, validator: AngleValidator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert 'Invalid value' in str(validation_failure.value)

Diff for: _plotly_utils/tests/validators/test_angle_validator.py

@@ -0,0 +1,36 @@
+import pytest
+from _plotly_utils.basevalidators import AnyValidator
+import numpy as np
+
+
+# Fixtures
+# --------
+@pytest.fixture()
+def validator():
+    return AnyValidator('prop', 'parent')
+
+
+@pytest.fixture()
+def validator_aok():
+    return AnyValidator('prop', 'parent', array_ok=True)
+
+
+# Tests
+# -----
+# ### Acceptance ###
+@pytest.mark.parametrize('val', [
+    set(), 'Hello', 123, np.inf, np.nan, {}
+])
+def test_acceptance(val, validator: AnyValidator):
+    assert validator.validate_coerce(val) is val
+
+
+# ### Acceptance of arrays ###
+@pytest.mark.parametrize('val', [
+    [], np.array([]), ['Hello', 'World'], [np.pi, np.e, {}]
+])
+def test_acceptance_array(val, validator_aok: AnyValidator):
+    coerce_val = validator_aok.validate_coerce(val)
+    assert isinstance(coerce_val, np.ndarray)
+    assert coerce_val.dtype == 'object'
+    assert np.array_equal(coerce_val, val)

Diff for: _plotly_utils/tests/validators/test_any_validator.py

@@ -0,0 +1,98 @@
+import pytest
+from _plotly_utils.basevalidators import BaseDataValidator
+from plotly.graph_objs import Scatter, Bar, Box
+
+# Fixtures
+# --------
+@pytest.fixture()
+def validator():
+    return BaseDataValidator(class_strs_map={'scatter': 'Scatter',
+                                        'bar': 'Bar',
+                                        'box': 'Box'},
+                             plotly_name='prop',
+                             parent_name='parent')
+
+
+# Tests
+# -----
+def test_acceptance(validator: BaseDataValidator):
+    val = [Scatter(mode='lines'), Box(fillcolor='yellow')]
+    res = validator.validate_coerce(val)
+
+    assert isinstance(res, tuple)
+    assert isinstance(res[0], Scatter)
+    assert res[0].type == 'scatter'
+    assert res[0].mode == 'lines'
+
+    assert isinstance(res[1], Box)
+    assert res[1].type == 'box'
+    assert res[1].fillcolor == 'yellow'
+
+    # Make sure UIDs are actually unique
+    assert res[0].uid != res[1].uid
+
+
+def test_acceptance_dict(validator: BaseDataValidator):
+    val = (dict(type='scatter', mode='lines'),
+           dict(type='box', fillcolor='yellow'))
+    res = validator.validate_coerce(val)
+
+    assert isinstance(res, tuple)
+    assert isinstance(res[0], Scatter)
+    assert res[0].type == 'scatter'
+    assert res[0].mode == 'lines'
+
+    assert isinstance(res[1], Box)
+    assert res[1].type == 'box'
+    assert res[1].fillcolor == 'yellow'
+
+    # Make sure UIDs are actually unique
+    assert res[0].uid != res[1].uid
+
+
+def test_default_is_scatter(validator: BaseDataValidator):
+    val = [dict(mode='lines')]
+    res = validator.validate_coerce(val)
+
+    assert isinstance(res, tuple)
+    assert isinstance(res[0], Scatter)
+    assert res[0].type == 'scatter'
+    assert res[0].mode == 'lines'
+
+
+def test_rejection_type(validator: BaseDataValidator):
+    val = 37
+
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert "Invalid value" in str(validation_failure.value)
+
+
+def test_rejection_element_type(validator: BaseDataValidator):
+    val = [42]
+
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert "Invalid element(s)" in str(validation_failure.value)
+
+
+def test_rejection_element_attr(validator: BaseDataValidator):
+    val = [dict(type='scatter', bogus=99)]
+
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert ("Invalid property specified for object of type " +
+            "plotly.graph_objs.Scatter: 'bogus'" in
+            str(validation_failure.value))
+
+
+def test_rejection_element_tracetype(validator: BaseDataValidator):
+    val = [dict(type='bogus', a=4)]
+
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert "Invalid element(s)" in str(validation_failure.value)

Diff for: _plotly_utils/tests/validators/test_basetraces_validator.py

@@ -0,0 +1,27 @@
+import pytest
+from _plotly_utils.basevalidators import BooleanValidator
+import numpy as np
+
+
+# Boolean Validator
+# =================
+# ### Fixtures ###
+@pytest.fixture(params=[True, False])
+def validator(request):
+    return BooleanValidator('prop', 'parent', dflt=request.param)
+
+
+# ### Acceptance ###
+@pytest.mark.parametrize('val', [True, False])
+def test_acceptance(val, validator):
+    assert val == validator.validate_coerce(val)
+
+
+# ### Rejection ###
+@pytest.mark.parametrize('val',
+                         [1.0, 0.0, 'True', 'False', [], 0, np.nan])
+def test_rejection(val, validator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert 'Invalid value' in str(validation_failure.value)

Diff for: _plotly_utils/tests/validators/test_boolean_validator.py

@@ -0,0 +1,182 @@
+import pytest
+from _plotly_utils.basevalidators import ColorValidator
+import numpy as np
+
+
+# Fixtures
+# --------
+@pytest.fixture()
+def validator():
+    return ColorValidator('prop', 'parent')
+
+
+@pytest.fixture()
+def validator_colorscale():
+    return ColorValidator('prop', 'parent', colorscale_path='parent.colorscale')
+
+
+@pytest.fixture()
+def validator_aok():
+    return ColorValidator('prop', 'parent', array_ok=True)
+
+
+@pytest.fixture()
+def validator_aok_colorscale():
+    return ColorValidator('prop', 'parent', array_ok=True, colorscale_path='parent.colorscale')
+
+
+# Array not ok, numbers not ok
+# ----------------------------
+@pytest.mark.parametrize('val',
+                         ['red', 'BLUE', 'rgb(255, 0, 0)', 'hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)',
+                          'hsv(0, 100%, 100%)', 'hsva(0, 100%, 100%, 50%)'])
+def test_acceptance(val, validator: ColorValidator):
+    if isinstance(val, str):
+        assert validator.validate_coerce(val) == str.replace(val.lower(), ' ', '')
+    else:
+        assert validator.validate_coerce(val) == val
+
+
+# ### Rejection by type ###
+@pytest.mark.parametrize('val',
+                         [set(), 23, 0.5, {}, ['red'], [12]])
+def test_rejection(val, validator: ColorValidator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert 'Invalid value' in str(validation_failure.value)
+
+
+# ### Rejection by value ###
+@pytest.mark.parametrize('val',
+                         ['redd', 'rgbbb(255, 0, 0)', 'hsl(0, 1%0000%, 50%)'])
+def test_rejection(val, validator: ColorValidator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert 'Invalid value' in str(validation_failure.value)
+
+
+# Array not ok, numbers ok
+# ------------------------
+# ### Acceptance ###
+@pytest.mark.parametrize('val',
+                         ['red', 'BLUE', 23, 15, 'rgb(255, 0, 0)', 'hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)',
+                          'hsv(0, 100%, 100%)', 'hsva(0, 100%, 100%, 50%)'])
+def test_acceptance_colorscale(val, validator_colorscale: ColorValidator):
+    if isinstance(val, str):
+        assert validator_colorscale.validate_coerce(val) == str.replace(val.lower(), ' ', '')
+    else:
+        assert validator_colorscale.validate_coerce(val) == val
+
+
+# ### Rejection by type ###
+@pytest.mark.parametrize('val',
+                         [set(), {}, ['red'], [12]])
+def test_rejection_colorscale(val, validator_colorscale: ColorValidator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator_colorscale.validate_coerce(val)
+
+    assert 'Invalid value' in str(validation_failure.value)
+
+
+# ### Rejection by value ###
+@pytest.mark.parametrize('val',
+                         ['redd', 'rgbbb(255, 0, 0)', 'hsl(0, 1%0000%, 50%)'])
+def test_rejection_colorscale(val, validator_colorscale: ColorValidator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator_colorscale.validate_coerce(val)
+
+    assert 'Invalid value' in str(validation_failure.value)
+
+
+# Array ok, numbers not ok
+# ------------------------
+# ### Acceptance ###
+@pytest.mark.parametrize('val',
+                         ['blue',
+                          ['red', 'rgb(255, 0, 0)'],
+                          ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'],
+                          ['hsva(0, 100%, 100%, 50%)']])
+def test_acceptance_aok(val, validator_aok: ColorValidator):
+    coerce_val = validator_aok.validate_coerce(val)
+    if isinstance(val, (list, np.ndarray)):
+        expected = np.array(
+            [str.replace(v.lower(), ' ', '') if isinstance(v, str) else v for v in val],
+            dtype=coerce_val.dtype)
+        assert np.array_equal(coerce_val, expected)
+    else:
+        expected = str.replace(val.lower(), ' ', '') if isinstance(val, str) else val
+        assert coerce_val == expected
+
+
+# ### Rejection ###
+@pytest.mark.parametrize('val',
+                         [[23], [0, 1, 2],
+                          ['redd', 'rgb(255, 0, 0)'],
+                          ['hsl(0, 100%, 50_00%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'],
+                          ['hsva(0, 1%00%, 100%, 50%)']])
+def test_rejection_aok(val, validator_aok: ColorValidator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator_aok.validate_coerce(val)
+
+    assert 'Invalid element(s)' in str(validation_failure.value)
+
+
+# Array ok, numbers ok
+# --------------------
+# ### Acceptance ###
+@pytest.mark.parametrize('val',
+                         ['blue', 23, [0, 1, 2],
+                          ['red', 0.5, 'rgb(255, 0, 0)'],
+                          ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'],
+                          ['hsva(0, 100%, 100%, 50%)']])
+def test_acceptance_aok_colorscale(val, validator_aok_colorscale: ColorValidator):
+    coerce_val = validator_aok_colorscale.validate_coerce(val)
+    if isinstance(val, (list, np.ndarray)):
+        expected = np.array(
+            [str.replace(v.lower(), ' ', '') if isinstance(v, str) else v for v in val],
+            dtype=coerce_val.dtype)
+        assert np.array_equal(coerce_val, expected)
+    else:
+        expected = str.replace(val.lower(), ' ', '') if isinstance(val, str) else val
+        assert coerce_val == expected
+
+
+# ### Rejection ###
+@pytest.mark.parametrize('val',
+                         [['redd', 0.5, 'rgb(255, 0, 0)'],
+                          ['hsl(0, 100%, 50_00%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'],
+                          ['hsva(0, 1%00%, 100%, 50%)']])
+def test_rejection_aok_colorscale(val, validator_aok_colorscale: ColorValidator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator_aok_colorscale.validate_coerce(val)
+
+    assert 'Invalid element(s)' in str(validation_failure.value)
+
+
+# Description
+# -----------
+# Test dynamic description logic
+def test_description(validator: ColorValidator):
+    desc = validator.description()
+    assert 'A number that will be interpreted as a color' not in desc
+    assert 'A list or array of any of the above' not in desc
+
+
+def test_description_aok(validator_aok: ColorValidator):
+    desc = validator_aok.description()
+    assert 'A number that will be interpreted as a color' not in desc
+    assert 'A list or array of any of the above' in desc
+
+
+def test_description_aok(validator_colorscale: ColorValidator):
+    desc = validator_colorscale.description()
+    assert 'A number that will be interpreted as a color' in desc
+    assert 'A list or array of any of the above' not in desc
+
+
+def test_description_aok_colorscale(validator_aok_colorscale: ColorValidator):
+    desc = validator_aok_colorscale.description()
+    assert 'A number that will be interpreted as a color' in desc
+    assert 'A list or array of any of the above' in desc