tests/test_ipynb.py

   1 import re
   2
   3 from click.testing import CliRunner
   4 from black.handle_ipynb_magics import jupyter_dependencies_are_installed
   5 from black import (
   6     main,
   7     NothingChanged,
   8     format_cell,
   9     format_file_contents,
  10     format_file_in_place,
  11 )
  12 import pytest
  13 from black import Mode
  14 from _pytest.monkeypatch import MonkeyPatch
  15 from py.path import local
  16 from tests.util import DATA_DIR
  17
  18 pytestmark = pytest.mark.jupyter
  19 pytest.importorskip("IPython", reason="IPython is an optional dependency")
  20 pytest.importorskip("tokenize_rt", reason="tokenize-rt is an optional dependency")
  21
  22 JUPYTER_MODE = Mode(is_ipynb=True)
  23
  24 runner = CliRunner()
  25
  26
  27 def test_noop() -> None:
  28     src = 'foo = "a"'
  29     with pytest.raises(NothingChanged):
  30         format_cell(src, fast=True, mode=JUPYTER_MODE)
  31
  32
  33 @pytest.mark.parametrize("fast", [True, False])
  34 def test_trailing_semicolon(fast: bool) -> None:
  35     src = 'foo = "a" ;'
  36     result = format_cell(src, fast=fast, mode=JUPYTER_MODE)
  37     expected = 'foo = "a";'
  38     assert result == expected
  39
  40
  41 def test_trailing_semicolon_with_comment() -> None:
  42     src = 'foo = "a" ;  # bar'
  43     result = format_cell(src, fast=True, mode=JUPYTER_MODE)
  44     expected = 'foo = "a";  # bar'
  45     assert result == expected
  46
  47
  48 def test_trailing_semicolon_with_comment_on_next_line() -> None:
  49     src = "import black;\n\n# this is a comment"
  50     with pytest.raises(NothingChanged):
  51         format_cell(src, fast=True, mode=JUPYTER_MODE)
  52
  53
  54 def test_trailing_semicolon_indented() -> None:
  55     src = "with foo:\n    plot_bar();"
  56     with pytest.raises(NothingChanged):
  57         format_cell(src, fast=True, mode=JUPYTER_MODE)
  58
  59
  60 def test_trailing_semicolon_noop() -> None:
  61     src = 'foo = "a";'
  62     with pytest.raises(NothingChanged):
  63         format_cell(src, fast=True, mode=JUPYTER_MODE)
  64
  65
  66 def test_cell_magic() -> None:
  67     src = "%%time\nfoo =bar"
  68     result = format_cell(src, fast=True, mode=JUPYTER_MODE)
  69     expected = "%%time\nfoo = bar"
  70     assert result == expected
  71
  72
  73 def test_cell_magic_noop() -> None:
  74     src = "%%time\n2 + 2"
  75     with pytest.raises(NothingChanged):
  76         format_cell(src, fast=True, mode=JUPYTER_MODE)
  77
  78
  79 @pytest.mark.parametrize(
  80     "src, expected",
  81     (
  82         pytest.param("ls =!ls", "ls = !ls", id="System assignment"),
  83         pytest.param("!ls\n'foo'", '!ls\n"foo"', id="System call"),
  84         pytest.param("!!ls\n'foo'", '!!ls\n"foo"', id="Other system call"),
  85         pytest.param("?str\n'foo'", '?str\n"foo"', id="Help"),
  86         pytest.param("??str\n'foo'", '??str\n"foo"', id="Other help"),
  87         pytest.param(
  88             "%matplotlib inline\n'foo'",
  89             '%matplotlib inline\n"foo"',
  90             id="Line magic with argument",
  91         ),
  92         pytest.param("%time\n'foo'", '%time\n"foo"', id="Line magic without argument"),
  93     ),
  94 )
  95 def test_magic(src: str, expected: str) -> None:
  96     result = format_cell(src, fast=True, mode=JUPYTER_MODE)
  97     assert result == expected
  98
  99
 100 @pytest.mark.parametrize(
 101     "src",
 102     (
 103         "%%bash\n2+2",
 104         "%%html --isolated\n2+2",
 105     ),
 106 )
 107 def test_non_python_magics(src: str) -> None:
 108     with pytest.raises(NothingChanged):
 109         format_cell(src, fast=True, mode=JUPYTER_MODE)
 110
 111
 112 def test_set_input() -> None:
 113     src = "a = b??"
 114     with pytest.raises(NothingChanged):
 115         format_cell(src, fast=True, mode=JUPYTER_MODE)
 116
 117
 118 def test_input_already_contains_transformed_magic() -> None:
 119     src = '%time foo()\nget_ipython().run_cell_magic("time", "", "foo()\\n")'
 120     with pytest.raises(NothingChanged):
 121         format_cell(src, fast=True, mode=JUPYTER_MODE)
 122
 123
 124 def test_magic_noop() -> None:
 125     src = "ls = !ls"
 126     with pytest.raises(NothingChanged):
 127         format_cell(src, fast=True, mode=JUPYTER_MODE)
 128
 129
 130 def test_cell_magic_with_magic() -> None:
 131     src = "%%t -n1\nls =!ls"
 132     result = format_cell(src, fast=True, mode=JUPYTER_MODE)
 133     expected = "%%t -n1\nls = !ls"
 134     assert result == expected
 135
 136
 137 def test_cell_magic_nested() -> None:
 138     src = "%%time\n%%time\n2+2"
 139     result = format_cell(src, fast=True, mode=JUPYTER_MODE)
 140     expected = "%%time\n%%time\n2 + 2"
 141     assert result == expected
 142
 143
 144 def test_cell_magic_with_magic_noop() -> None:
 145     src = "%%t -n1\nls = !ls"
 146     with pytest.raises(NothingChanged):
 147         format_cell(src, fast=True, mode=JUPYTER_MODE)
 148
 149
 150 def test_automagic() -> None:
 151     src = "pip install black"
 152     with pytest.raises(NothingChanged):
 153         format_cell(src, fast=True, mode=JUPYTER_MODE)
 154
 155
 156 def test_multiline_magic() -> None:
 157     src = "%time 1 + \\\n2"
 158     with pytest.raises(NothingChanged):
 159         format_cell(src, fast=True, mode=JUPYTER_MODE)
 160
 161
 162 def test_multiline_no_magic() -> None:
 163     src = "1 + \\\n2"
 164     result = format_cell(src, fast=True, mode=JUPYTER_MODE)
 165     expected = "1 + 2"
 166     assert result == expected
 167
 168
 169 def test_cell_magic_with_invalid_body() -> None:
 170     src = "%%time\nif True"
 171     with pytest.raises(NothingChanged):
 172         format_cell(src, fast=True, mode=JUPYTER_MODE)
 173
 174
 175 def test_empty_cell() -> None:
 176     src = ""
 177     with pytest.raises(NothingChanged):
 178         format_cell(src, fast=True, mode=JUPYTER_MODE)
 179
 180
 181 def test_entire_notebook_empty_metadata() -> None:
 182     with open(DATA_DIR / "notebook_empty_metadata.ipynb", "rb") as fd:
 183         content_bytes = fd.read()
 184     content = content_bytes.decode()
 185     result = format_file_contents(content, fast=True, mode=JUPYTER_MODE)
 186     expected = (
 187         "{\n"
 188         ' "cells": [\n'
 189         "  {\n"
 190         '   "cell_type": "code",\n'
 191         '   "execution_count": null,\n'
 192         '   "metadata": {\n'
 193         '    "tags": []\n'
 194         "   },\n"
 195         '   "outputs": [],\n'
 196         '   "source": [\n'
 197         '    "%%time\\n",\n'
 198         '    "\\n",\n'
 199         '    "print(\\"foo\\")"\n'
 200         "   ]\n"
 201         "  },\n"
 202         "  {\n"
 203         '   "cell_type": "code",\n'
 204         '   "execution_count": null,\n'
 205         '   "metadata": {},\n'
 206         '   "outputs": [],\n'
 207         '   "source": []\n'
 208         "  }\n"
 209         " ],\n"
 210         ' "metadata": {},\n'
 211         ' "nbformat": 4,\n'
 212         ' "nbformat_minor": 4\n'
 213         "}\n"
 214     )
 215     assert result == expected
 216
 217
 218 def test_entire_notebook_trailing_newline() -> None:
 219     with open(DATA_DIR / "notebook_trailing_newline.ipynb", "rb") as fd:
 220         content_bytes = fd.read()
 221     content = content_bytes.decode()
 222     result = format_file_contents(content, fast=True, mode=JUPYTER_MODE)
 223     expected = (
 224         "{\n"
 225         ' "cells": [\n'
 226         "  {\n"
 227         '   "cell_type": "code",\n'
 228         '   "execution_count": null,\n'
 229         '   "metadata": {\n'
 230         '    "tags": []\n'
 231         "   },\n"
 232         '   "outputs": [],\n'
 233         '   "source": [\n'
 234         '    "%%time\\n",\n'
 235         '    "\\n",\n'
 236         '    "print(\\"foo\\")"\n'
 237         "   ]\n"
 238         "  },\n"
 239         "  {\n"
 240         '   "cell_type": "code",\n'
 241         '   "execution_count": null,\n'
 242         '   "metadata": {},\n'
 243         '   "outputs": [],\n'
 244         '   "source": []\n'
 245         "  }\n"
 246         " ],\n"
 247         ' "metadata": {\n'
 248         '  "interpreter": {\n'
 249         '   "hash": "e758f3098b5b55f4d87fe30bbdc1367f20f246b483f96267ee70e6c40cb185d8"\n'  # noqa:B950
 250         "  },\n"
 251         '  "kernelspec": {\n'
 252         '   "display_name": "Python 3.8.10 64-bit (\'black\': venv)",\n'
 253         '   "name": "python3"\n'
 254         "  },\n"
 255         '  "language_info": {\n'
 256         '   "name": "python",\n'
 257         '   "version": ""\n'
 258         "  }\n"
 259         " },\n"
 260         ' "nbformat": 4,\n'
 261         ' "nbformat_minor": 4\n'
 262         "}\n"
 263     )
 264     assert result == expected
 265
 266
 267 def test_entire_notebook_no_trailing_newline() -> None:
 268     with open(DATA_DIR / "notebook_no_trailing_newline.ipynb", "rb") as fd:
 269         content_bytes = fd.read()
 270     content = content_bytes.decode()
 271     result = format_file_contents(content, fast=True, mode=JUPYTER_MODE)
 272     expected = (
 273         "{\n"
 274         ' "cells": [\n'
 275         "  {\n"
 276         '   "cell_type": "code",\n'
 277         '   "execution_count": null,\n'
 278         '   "metadata": {\n'
 279         '    "tags": []\n'
 280         "   },\n"
 281         '   "outputs": [],\n'
 282         '   "source": [\n'
 283         '    "%%time\\n",\n'
 284         '    "\\n",\n'
 285         '    "print(\\"foo\\")"\n'
 286         "   ]\n"
 287         "  },\n"
 288         "  {\n"
 289         '   "cell_type": "code",\n'
 290         '   "execution_count": null,\n'
 291         '   "metadata": {},\n'
 292         '   "outputs": [],\n'
 293         '   "source": []\n'
 294         "  }\n"
 295         " ],\n"
 296         ' "metadata": {\n'
 297         '  "interpreter": {\n'
 298         '   "hash": "e758f3098b5b55f4d87fe30bbdc1367f20f246b483f96267ee70e6c40cb185d8"\n'  # noqa: B950
 299         "  },\n"
 300         '  "kernelspec": {\n'
 301         '   "display_name": "Python 3.8.10 64-bit (\'black\': venv)",\n'
 302         '   "name": "python3"\n'
 303         "  },\n"
 304         '  "language_info": {\n'
 305         '   "name": "python",\n'
 306         '   "version": ""\n'
 307         "  }\n"
 308         " },\n"
 309         ' "nbformat": 4,\n'
 310         ' "nbformat_minor": 4\n'
 311         "}"
 312     )
 313     assert result == expected
 314
 315
 316 def test_entire_notebook_without_changes() -> None:
 317     with open(DATA_DIR / "notebook_without_changes.ipynb", "rb") as fd:
 318         content_bytes = fd.read()
 319     content = content_bytes.decode()
 320     with pytest.raises(NothingChanged):
 321         format_file_contents(content, fast=True, mode=JUPYTER_MODE)
 322
 323
 324 def test_non_python_notebook() -> None:
 325     with open(DATA_DIR / "non_python_notebook.ipynb", "rb") as fd:
 326         content_bytes = fd.read()
 327     content = content_bytes.decode()
 328     with pytest.raises(NothingChanged):
 329         format_file_contents(content, fast=True, mode=JUPYTER_MODE)
 330
 331
 332 def test_empty_string() -> None:
 333     with pytest.raises(NothingChanged):
 334         format_file_contents("", fast=True, mode=JUPYTER_MODE)
 335
 336
 337 def test_unparseable_notebook() -> None:
 338     path = DATA_DIR / "notebook_which_cant_be_parsed.ipynb"
 339     msg = rf"File '{re.escape(str(path))}' cannot be parsed as valid Jupyter notebook\."
 340     with pytest.raises(ValueError, match=msg):
 341         format_file_in_place(path, fast=True, mode=JUPYTER_MODE)
 342
 343
 344 def test_ipynb_diff_with_change() -> None:
 345     result = runner.invoke(
 346         main,
 347         [
 348             str(DATA_DIR / "notebook_trailing_newline.ipynb"),
 349             "--diff",
 350         ],
 351     )
 352     expected = "@@ -1,3 +1,3 @@\n %%time\n \n-print('foo')\n" '+print("foo")\n'
 353     assert expected in result.output
 354
 355
 356 def test_ipynb_diff_with_no_change() -> None:
 357     result = runner.invoke(
 358         main,
 359         [
 360             str(DATA_DIR / "notebook_without_changes.ipynb"),
 361             "--diff",
 362         ],
 363     )
 364     expected = "1 file would be left unchanged."
 365     assert expected in result.output
 366
 367
 368 def test_cache_isnt_written_if_no_jupyter_deps_single(
 369     monkeypatch: MonkeyPatch, tmpdir: local
 370 ) -> None:
 371     # Check that the cache isn't written to if Jupyter dependencies aren't installed.
 372     jupyter_dependencies_are_installed.cache_clear()
 373     nb = DATA_DIR / "notebook_trailing_newline.ipynb"
 374     tmp_nb = tmpdir / "notebook.ipynb"
 375     with open(nb) as src, open(tmp_nb, "w") as dst:
 376         dst.write(src.read())
 377     monkeypatch.setattr(
 378         "black.jupyter_dependencies_are_installed", lambda verbose, quiet: False
 379     )
 380     result = runner.invoke(main, [str(tmpdir / "notebook.ipynb")])
 381     assert "No Python files are present to be formatted. Nothing to do" in result.output
 382     jupyter_dependencies_are_installed.cache_clear()
 383     monkeypatch.setattr(
 384         "black.jupyter_dependencies_are_installed", lambda verbose, quiet: True
 385     )
 386     result = runner.invoke(main, [str(tmpdir / "notebook.ipynb")])
 387     assert "reformatted" in result.output
 388
 389
 390 def test_cache_isnt_written_if_no_jupyter_deps_dir(
 391     monkeypatch: MonkeyPatch, tmpdir: local
 392 ) -> None:
 393     # Check that the cache isn't written to if Jupyter dependencies aren't installed.
 394     jupyter_dependencies_are_installed.cache_clear()
 395     nb = DATA_DIR / "notebook_trailing_newline.ipynb"
 396     tmp_nb = tmpdir / "notebook.ipynb"
 397     with open(nb) as src, open(tmp_nb, "w") as dst:
 398         dst.write(src.read())
 399     monkeypatch.setattr(
 400         "black.files.jupyter_dependencies_are_installed", lambda verbose, quiet: False
 401     )
 402     result = runner.invoke(main, [str(tmpdir)])
 403     assert "No Python files are present to be formatted. Nothing to do" in result.output
 404     jupyter_dependencies_are_installed.cache_clear()
 405     monkeypatch.setattr(
 406         "black.files.jupyter_dependencies_are_installed", lambda verbose, quiet: True
 407     )
 408     result = runner.invoke(main, [str(tmpdir)])
 409     assert "reformatted" in result.output
 410
 411
 412 def test_ipynb_flag(tmpdir: local) -> None:
 413     nb = DATA_DIR / "notebook_trailing_newline.ipynb"
 414     tmp_nb = tmpdir / "notebook.a_file_extension_which_is_definitely_not_ipynb"
 415     with open(nb) as src, open(tmp_nb, "w") as dst:
 416         dst.write(src.read())
 417     result = runner.invoke(
 418         main,
 419         [
 420             str(tmp_nb),
 421             "--diff",
 422             "--ipynb",
 423         ],
 424     )
 425     expected = "@@ -1,3 +1,3 @@\n %%time\n \n-print('foo')\n" '+print("foo")\n'
 426     assert expected in result.output
 427
 428
 429 def test_ipynb_and_pyi_flags() -> None:
 430     nb = DATA_DIR / "notebook_trailing_newline.ipynb"
 431     result = runner.invoke(
 432         main,
 433         [
 434             str(nb),
 435             "--pyi",
 436             "--ipynb",
 437             "--diff",
 438         ],
 439     )
 440     assert isinstance(result.exception, SystemExit)
 441     expected = "Cannot pass both `pyi` and `ipynb` flags!\n"
 442     assert result.output == expected
 443
 444
 445 def test_unable_to_replace_magics(monkeypatch: MonkeyPatch) -> None:
 446     src = "%%time\na = 'foo'"
 447     monkeypatch.setattr("black.handle_ipynb_magics.TOKEN_HEX", lambda _: "foo")
 448     with pytest.raises(
 449         AssertionError, match="Black was not able to replace IPython magic"
 450     ):
 451         format_cell(src, fast=True, mode=JUPYTER_MODE)