update tests for kaleido v0 removal, and add test for error when kaleido v0 is used

Author: emilykl

tests/test_io/test_renderers.py

@@ -121,11 +121,6 @@ def test_plotly_mimetype_renderer_show(fig1, renderer):
     mock_display.assert_called_once_with(expected, raw=True)
 
 
-# Static Image
-# ------------
-# See tests/test_orca/test_image_renderers.py
-
-
 # HTML
 # ----
 def assert_full_html(html):
@@ -327,7 +322,7 @@ def test_repr_html(renderer):
         assert str_html.replace(id_html, "") == template.replace(id_pattern, "")
 
 
-all_renderers_without_orca = [
+all_renderers = [
     "plotly_mimetype",
     "jupyterlab",
     "nteract",
@@ -350,7 +345,7 @@ def test_repr_html(renderer):
 ]
 
 
-@pytest.mark.parametrize("renderer_str", all_renderers_without_orca)
+@pytest.mark.parametrize("renderer_str", all_renderers)
 def test_repr_mimebundle(renderer_str):
     pio.renderers.default = renderer_str
     fig = go.Figure()

tests/test_optional/test_kaleido/test_kaleido.py

@@ -10,8 +10,6 @@
 from PIL import Image
 import plotly.graph_objects as go
 import plotly.io as pio
-from plotly.io.kaleido import kaleido_available, kaleido_major
-import pytest
 
 
 fig = {"data": [], "layout": {"title": {"text": "figure title"}}}
@@ -56,8 +54,8 @@ def check_image(path_or_buffer, size=(700, 500), format="PNG"):
         assert img.format == format
 
 
-def test_kaleido_engine_to_image_returns_bytes():
-    result = pio.to_image(fig, format="svg", engine="kaleido", validate=False)
+def test_kaleido_to_image_returns_bytes():
+    result = pio.to_image(fig, format="svg", validate=False)
     assert result.startswith(b"<svg")
 
 
@@ -67,37 +65,36 @@ def test_kaleido_fulljson():
     assert result["layout"]["calendar"] == "gregorian"
 
 
-def test_kaleido_engine_to_image():
-    bytes = pio.to_image(fig, engine="kaleido", validate=False)
+def test_kaleido_to_image():
+    bytes = pio.to_image(fig, validate=False)
 
     # Check that image dimensions match default dimensions (700x500)
     # and format is default format (png)
     check_image(BytesIO(bytes))
 
 
-def test_kaleido_engine_write_image(tmp_path):
+def test_kaleido_write_image(tmp_path):
     path_str = tempfile.mkstemp(suffix=".png", dir=tmp_path)[1]
     path_path = Path(tempfile.mkstemp(suffix=".png", dir=tmp_path)[1])
 
     for out_path in [path_str, path_path]:
-        pio.write_image(fig, out_path, engine="kaleido", validate=False)
+        pio.write_image(fig, out_path, validate=False)
         check_image(out_path)
 
 
-def test_kaleido_engine_to_image_kwargs():
+def test_kaleido_to_image_kwargs():
     bytes = pio.to_image(
         fig,
         format="pdf",
         width=700,
         height=600,
         scale=2,
-        engine="kaleido",
         validate=False,
     )
     check_image(BytesIO(bytes), size=(700 * 2, 600 * 2), format="PDF")
 
 
-def test_kaleido_engine_write_image_kwargs(tmp_path):
+def test_kaleido_write_image_kwargs(tmp_path):
     path_str = tempfile.mkstemp(suffix=".png", dir=tmp_path)[1]
     path_path = Path(tempfile.mkstemp(suffix=".png", dir=tmp_path)[1])
 
@@ -109,17 +106,12 @@ def test_kaleido_engine_write_image_kwargs(tmp_path):
             width=700,
             height=600,
             scale=2,
-            engine="kaleido",
             validate=False,
         )
         check_image(out_path, size=(700 * 2, 600 * 2), format="JPEG")
 
 
-@pytest.mark.skipif(
-    not kaleido_available() or kaleido_major() < 1,
-    reason="requires Kaleido v1.0.0 or higher",
-)
-def test_kaleido_engine_write_images(tmp_path):
+def test_kaleido_write_images(tmp_path):
     fig1 = {"data": [], "layout": {"title": {"text": "figure 1"}}}
     fig2 = {"data": [], "layout": {"title": {"text": "figure 2"}}}
 
@@ -142,15 +134,14 @@ def test_kaleido_engine_write_images(tmp_path):
 def test_image_renderer():
     """Verify that the image renderer returns the expected mimebundle."""
     with redirect_stdout(StringIO()) as f:
-        pio.show(fig, renderer="png", engine="kaleido", validate=False)
+        pio.show(fig, renderer="png", validate=False)
     mimebundle = f.getvalue().strip()
     mimebundle_expected = str(
         {
             "image/png": base64.b64encode(
                 pio.to_image(
                     fig,
                     format="png",
-                    engine="kaleido",
                     validate=False,
                 )
             ).decode("utf8")
@@ -166,10 +157,10 @@ def test_bytesio():
     which doesn't correspond to a filesystem path.
     """
     bio = BytesIO()
-    pio.write_image(fig, bio, format="jpg", engine="kaleido", validate=False)
+    pio.write_image(fig, bio, format="jpg", validate=False)
     bio.seek(0)  # Rewind to the beginning of the buffer, otherwise read() returns b''.
     bio_bytes = bio.read()
-    to_image_bytes = pio.to_image(fig, format="jpg", engine="kaleido", validate=False)
+    to_image_bytes = pio.to_image(fig, format="jpg", validate=False)
     assert bio_bytes == to_image_bytes
 
 
@@ -211,45 +202,29 @@ def test_defaults():
         assert pio.defaults.topojson == "path/to/topojson/files/"
         assert pio.defaults.plotlyjs == "https://cdn.plot.ly/plotly-3.0.0.js"
 
-        if kaleido_major() > 0:
-            # Check that all the defaults values are passed through to the function call to calc_fig_sync
-            with patch(
-                "plotly.io._kaleido.kaleido.calc_fig_sync",
-                return_value=test_image_bytes,
-            ) as mock_calc_fig:
-                result = pio.to_image(test_fig, validate=False)
-
-                # Verify calc_fig_sync was called with correct args
-                # taken from pio.defaults
-                mock_calc_fig.assert_called_once()
-                args, kwargs = mock_calc_fig.call_args
-                assert args[0] == test_fig.to_dict()
-                assert kwargs["opts"]["format"] == "svg"
-                assert kwargs["opts"]["width"] == 701
-                assert kwargs["opts"]["height"] == 501
-                assert kwargs["opts"]["scale"] == 2
-                assert kwargs["topojson"] == "path/to/topojson/files/"
-                # mathjax and plotlyjs are passed through in kopts
-                assert (
-                    kwargs["kopts"]["mathjax"]
-                    == "https://cdn.jsdelivr.net/npm/mathjax@3.1.2/es5/tex-svg.js"
-                )
-                assert (
-                    kwargs["kopts"]["plotlyjs"] == "https://cdn.plot.ly/plotly-3.0.0.js"
-                )
-
-        else:
-            # Check that all the default values have been set in pio._kaleido.scope
-            assert pio._kaleido.scope.default_format == "svg"
-            assert pio._kaleido.scope.default_width == 701
-            assert pio._kaleido.scope.default_height == 501
-            assert pio._kaleido.scope.default_scale == 2
+        # Check that all the defaults values are passed through to the function call to calc_fig_sync
+        with patch(
+            "plotly.io._kaleido.kaleido.calc_fig_sync",
+            return_value=test_image_bytes,
+        ) as mock_calc_fig:
+            result = pio.to_image(test_fig, validate=False)
+
+            # Verify calc_fig_sync was called with correct args
+            # taken from pio.defaults
+            mock_calc_fig.assert_called_once()
+            args, kwargs = mock_calc_fig.call_args
+            assert args[0] == test_fig.to_dict()
+            assert kwargs["opts"]["format"] == "svg"
+            assert kwargs["opts"]["width"] == 701
+            assert kwargs["opts"]["height"] == 501
+            assert kwargs["opts"]["scale"] == 2
+            assert kwargs["topojson"] == "path/to/topojson/files/"
+            # mathjax and plotlyjs are passed through in kopts
             assert (
-                pio._kaleido.scope.mathjax
+                kwargs["kopts"]["mathjax"]
                 == "https://cdn.jsdelivr.net/npm/mathjax@3.1.2/es5/tex-svg.js"
             )
-            assert pio._kaleido.scope.topojson == "path/to/topojson/files/"
-            assert pio._kaleido.scope.plotlyjs == "https://cdn.plot.ly/plotly-3.0.0.js"
+            assert kwargs["kopts"]["plotlyjs"] == "https://cdn.plot.ly/plotly-3.0.0.js"
 
         # Set topojson default back to None
         # (otherwise image generation will fail)
@@ -282,12 +257,9 @@ def test_fig_write_image():
     test_fig = go.Figure(fig)
     test_image_bytes = b"mock image data"
 
-    if kaleido_major() > 0:
-        patch_funcname = "plotly.io._kaleido.kaleido.calc_fig_sync"
-    else:
-        patch_funcname = "plotly.io._kaleido.scope.transform"
-
-    with patch(patch_funcname, return_value=test_image_bytes) as mock_calc_fig:
+    with patch(
+        "plotly.io._kaleido.kaleido.calc_fig_sync", return_value=test_image_bytes
+    ) as mock_calc_fig:
         test_fig.write_image("test_path.png")
 
         # Verify patched function was called once with fig dict as first argument
@@ -302,12 +274,9 @@ def test_fig_to_image():
     test_fig = go.Figure(fig)
     test_image_bytes = b"mock image data"
 
-    if kaleido_major() > 0:
-        patch_funcname = "plotly.io._kaleido.kaleido.calc_fig_sync"
-    else:
-        patch_funcname = "plotly.io._kaleido.scope.transform"
-
-    with patch(patch_funcname, return_value=test_image_bytes) as mock_calc_fig:
+    with patch(
+        "plotly.io._kaleido.kaleido.calc_fig_sync", return_value=test_image_bytes
+    ) as mock_calc_fig:
         test_fig.to_image()
 
         # Verify patched function was called once with fig dict as first argument
@@ -319,22 +288,14 @@ def test_fig_to_image():
 def test_get_chrome():
     """Test that plotly.io.get_chrome() can be called."""
 
-    if not kaleido_available() or kaleido_major() < 1:
-        # Test that ValueError is raised when Kaleido requirements aren't met
-        with pytest.raises(
-            ValueError, match="This command requires Kaleido v1.0.0 or greater"
-        ):
-            pio.get_chrome()
-    else:
-        # Test normal operation when Kaleido v1+ is available
-        with patch(
-            "plotly.io._kaleido.kaleido.get_chrome_sync",
-            return_value="/mock/path/to/chrome",
-        ) as mock_get_chrome:
-            pio.get_chrome()
+    with patch(
+        "plotly.io._kaleido.kaleido.get_chrome_sync",
+        return_value="/mock/path/to/chrome",
+    ) as mock_get_chrome:
+        pio.get_chrome()
 
-            # Verify that kaleido.get_chrome_sync was called
-            mock_get_chrome.assert_called_once()
+        # Verify that kaleido.get_chrome_sync was called
+        mock_get_chrome.assert_called_once()
 
 
 def test_width_height_priority():

tests/test_optional/test_kaleido/test_kaleido_v0_error.py

@@ -0,0 +1,78 @@
+"""
+Tests that every function requiring Kaleido raises a RuntimeError with the
+correct message when Kaleido v0 is installed.
+"""
+
+import pytest
+
+import plotly.graph_objects as go
+import plotly.io as pio
+from plotly.io._kaleido import kaleido_available
+
+
+# Skip every test in this module if Kaleido v1 is installed
+pytestmark = pytest.mark.skipif(
+    kaleido_available(),
+    reason="These tests only apply when Kaleido v1 is not installed.",
+)
+
+
+fig = {"data": [], "layout": {"title": {"text": "figure title"}}}
+
+
+def assert_error_message_contents(excinfo):
+    """Check that the raised RuntimeError has the expected wording."""
+    assert "Image export requires the Kaleido package, v1.0.0 or greater" in str(
+        excinfo.value
+    )
+
+
+# plotly/io/_kaleido.py
+
+
+def test_to_image_raises():
+    with pytest.raises(RuntimeError) as excinfo:
+        pio.to_image(fig, format="png", validate=False)
+    assert_error_message_contents(excinfo)
+
+
+def test_write_image_raises(tmp_path):
+    with pytest.raises(RuntimeError) as excinfo:
+        pio.write_image(fig, tmp_path / "test.png", validate=False)
+    assert_error_message_contents(excinfo)
+
+
+def test_full_figure_for_development_raises():
+    with pytest.raises(RuntimeError) as excinfo:
+        pio.full_figure_for_development(fig, warn=False)
+    assert_error_message_contents(excinfo)
+
+
+def test_get_chrome_raises():
+    with pytest.raises(RuntimeError) as excinfo:
+        pio.get_chrome()
+    assert_error_message_contents(excinfo)
+
+
+# plotly/basedatatypes.py
+
+
+def test_figure_to_image_raises():
+    test_fig = go.Figure(fig)
+    with pytest.raises(RuntimeError) as excinfo:
+        test_fig.to_image(format="png", validate=False)
+    assert_error_message_contents(excinfo)
+
+
+def test_figure_write_image_raises(tmp_path):
+    test_fig = go.Figure(fig)
+    with pytest.raises(RuntimeError) as excinfo:
+        test_fig.write_image(tmp_path / "test.png", validate=False)
+    assert_error_message_contents(excinfo)
+
+
+def test_figure_full_figure_for_development_raises():
+    test_fig = go.Figure(fig)
+    with pytest.raises(RuntimeError) as excinfo:
+        test_fig.full_figure_for_development(warn=False)
+    assert_error_message_contents(excinfo)