tests/test_black.py

   1 #!/usr/bin/env python3
   2 from functools import partial
   3 from io import StringIO
   4 import os
   5 from pathlib import Path
   6 import sys
   7 from typing import Any, List, Tuple
   8 import unittest
   9 from unittest.mock import patch
  10
  11 from click import unstyle
  12
  13 import black
  14
  15 ll = 88
  16 ff = partial(black.format_file_in_place, line_length=ll, fast=True)
  17 fs = partial(black.format_str, line_length=ll)
  18 THIS_FILE = Path(__file__)
  19 THIS_DIR = THIS_FILE.parent
  20 EMPTY_LINE = "# EMPTY LINE WITH WHITESPACE" + " (this comment will be removed)"
  21
  22
  23 def dump_to_stderr(*output: str) -> str:
  24     return "\n" + "\n".join(output) + "\n"
  25
  26
  27 def read_data(name: str) -> Tuple[str, str]:
  28     """read_data('test_name') -> 'input', 'output'"""
  29     if not name.endswith((".py", ".out", ".diff")):
  30         name += ".py"
  31     _input: List[str] = []
  32     _output: List[str] = []
  33     with open(THIS_DIR / name, "r", encoding="utf8") as test:
  34         lines = test.readlines()
  35     result = _input
  36     for line in lines:
  37         line = line.replace(EMPTY_LINE, "")
  38         if line.rstrip() == "# output":
  39             result = _output
  40             continue
  41
  42         result.append(line)
  43     if _input and not _output:
  44         # If there's no output marker, treat the entire file as already pre-formatted.
  45         _output = _input[:]
  46     return "".join(_input).strip() + "\n", "".join(_output).strip() + "\n"
  47
  48
  49 class BlackTestCase(unittest.TestCase):
  50     maxDiff = None
  51
  52     def assertFormatEqual(self, expected: str, actual: str) -> None:
  53         if actual != expected and not os.environ.get("SKIP_AST_PRINT"):
  54             bdv: black.DebugVisitor[Any]
  55             black.out("Expected tree:", fg="green")
  56             try:
  57                 exp_node = black.lib2to3_parse(expected)
  58                 bdv = black.DebugVisitor()
  59                 list(bdv.visit(exp_node))
  60             except Exception as ve:
  61                 black.err(str(ve))
  62             black.out("Actual tree:", fg="red")
  63             try:
  64                 exp_node = black.lib2to3_parse(actual)
  65                 bdv = black.DebugVisitor()
  66                 list(bdv.visit(exp_node))
  67             except Exception as ve:
  68                 black.err(str(ve))
  69         self.assertEqual(expected, actual)
  70
  71     @patch("black.dump_to_file", dump_to_stderr)
  72     def test_self(self) -> None:
  73         source, expected = read_data("test_black")
  74         actual = fs(source)
  75         self.assertFormatEqual(expected, actual)
  76         black.assert_equivalent(source, actual)
  77         black.assert_stable(source, actual, line_length=ll)
  78         self.assertFalse(ff(THIS_FILE))
  79
  80     @patch("black.dump_to_file", dump_to_stderr)
  81     def test_black(self) -> None:
  82         source, expected = read_data("../black")
  83         actual = fs(source)
  84         self.assertFormatEqual(expected, actual)
  85         black.assert_equivalent(source, actual)
  86         black.assert_stable(source, actual, line_length=ll)
  87         self.assertFalse(ff(THIS_DIR / ".." / "black.py"))
  88
  89     def test_piping(self) -> None:
  90         source, expected = read_data("../black")
  91         hold_stdin, hold_stdout = sys.stdin, sys.stdout
  92         try:
  93             sys.stdin, sys.stdout = StringIO(source), StringIO()
  94             sys.stdin.name = "<stdin>"
  95             black.format_stdin_to_stdout(
  96                 line_length=ll, fast=True, write_back=black.WriteBack.YES
  97             )
  98             sys.stdout.seek(0)
  99             actual = sys.stdout.read()
 100         finally:
 101             sys.stdin, sys.stdout = hold_stdin, hold_stdout
 102         self.assertFormatEqual(expected, actual)
 103         black.assert_equivalent(source, actual)
 104         black.assert_stable(source, actual, line_length=ll)
 105
 106     def test_piping_diff(self) -> None:
 107         source, _ = read_data("expression.py")
 108         expected, _ = read_data("expression.diff")
 109         hold_stdin, hold_stdout = sys.stdin, sys.stdout
 110         try:
 111             sys.stdin, sys.stdout = StringIO(source), StringIO()
 112             sys.stdin.name = "<stdin>"
 113             black.format_stdin_to_stdout(
 114                 line_length=ll, fast=True, write_back=black.WriteBack.DIFF
 115             )
 116             sys.stdout.seek(0)
 117             actual = sys.stdout.read()
 118         finally:
 119             sys.stdin, sys.stdout = hold_stdin, hold_stdout
 120         actual = actual.rstrip() + "\n"  # the diff output has a trailing space
 121         self.assertEqual(expected, actual)
 122
 123     @patch("black.dump_to_file", dump_to_stderr)
 124     def test_setup(self) -> None:
 125         source, expected = read_data("../setup")
 126         actual = fs(source)
 127         self.assertFormatEqual(expected, actual)
 128         black.assert_equivalent(source, actual)
 129         black.assert_stable(source, actual, line_length=ll)
 130         self.assertFalse(ff(THIS_DIR / ".." / "setup.py"))
 131
 132     @patch("black.dump_to_file", dump_to_stderr)
 133     def test_function(self) -> None:
 134         source, expected = read_data("function")
 135         actual = fs(source)
 136         self.assertFormatEqual(expected, actual)
 137         black.assert_equivalent(source, actual)
 138         black.assert_stable(source, actual, line_length=ll)
 139
 140     @patch("black.dump_to_file", dump_to_stderr)
 141     def test_expression(self) -> None:
 142         source, expected = read_data("expression")
 143         actual = fs(source)
 144         self.assertFormatEqual(expected, actual)
 145         black.assert_equivalent(source, actual)
 146         black.assert_stable(source, actual, line_length=ll)
 147
 148     def test_expression_ff(self) -> None:
 149         source, expected = read_data("expression")
 150         tmp_file = Path(black.dump_to_file(source))
 151         try:
 152             self.assertTrue(ff(tmp_file, write_back=black.WriteBack.YES))
 153             with open(tmp_file) as f:
 154                 actual = f.read()
 155         finally:
 156             os.unlink(tmp_file)
 157         self.assertFormatEqual(expected, actual)
 158         with patch("black.dump_to_file", dump_to_stderr):
 159             black.assert_equivalent(source, actual)
 160             black.assert_stable(source, actual, line_length=ll)
 161
 162     def test_expression_diff(self) -> None:
 163         source, _ = read_data("expression.py")
 164         expected, _ = read_data("expression.diff")
 165         tmp_file = Path(black.dump_to_file(source))
 166         hold_stdout = sys.stdout
 167         try:
 168             sys.stdout = StringIO()
 169             self.assertTrue(ff(tmp_file, write_back=black.WriteBack.DIFF))
 170             sys.stdout.seek(0)
 171             actual = sys.stdout.read()
 172             actual = actual.replace(tmp_file.name, "<stdin>")
 173         finally:
 174             sys.stdout = hold_stdout
 175             os.unlink(tmp_file)
 176         actual = actual.rstrip() + "\n"  # the diff output has a trailing space
 177         if expected != actual:
 178             dump = black.dump_to_file(actual)
 179             msg = (
 180                 f"Expected diff isn't equal to the actual. If you made changes "
 181                 f"to expression.py and this is an anticipated difference, "
 182                 f"overwrite tests/expression.diff with {dump}."
 183             )
 184             self.assertEqual(expected, actual, msg)
 185
 186     @patch("black.dump_to_file", dump_to_stderr)
 187     def test_fstring(self) -> None:
 188         source, expected = read_data("fstring")
 189         actual = fs(source)
 190         self.assertFormatEqual(expected, actual)
 191         black.assert_equivalent(source, actual)
 192         black.assert_stable(source, actual, line_length=ll)
 193
 194     @patch("black.dump_to_file", dump_to_stderr)
 195     def test_string_quotes(self) -> None:
 196         source, expected = read_data("string_quotes")
 197         actual = fs(source)
 198         self.assertFormatEqual(expected, actual)
 199         black.assert_equivalent(source, actual)
 200         black.assert_stable(source, actual, line_length=ll)
 201
 202     @patch("black.dump_to_file", dump_to_stderr)
 203     def test_comments(self) -> None:
 204         source, expected = read_data("comments")
 205         actual = fs(source)
 206         self.assertFormatEqual(expected, actual)
 207         black.assert_equivalent(source, actual)
 208         black.assert_stable(source, actual, line_length=ll)
 209
 210     @patch("black.dump_to_file", dump_to_stderr)
 211     def test_comments2(self) -> None:
 212         source, expected = read_data("comments2")
 213         actual = fs(source)
 214         self.assertFormatEqual(expected, actual)
 215         black.assert_equivalent(source, actual)
 216         black.assert_stable(source, actual, line_length=ll)
 217
 218     @patch("black.dump_to_file", dump_to_stderr)
 219     def test_comments3(self) -> None:
 220         source, expected = read_data("comments3")
 221         actual = fs(source)
 222         self.assertFormatEqual(expected, actual)
 223         black.assert_equivalent(source, actual)
 224         black.assert_stable(source, actual, line_length=ll)
 225
 226     @patch("black.dump_to_file", dump_to_stderr)
 227     def test_comments4(self) -> None:
 228         source, expected = read_data("comments4")
 229         actual = fs(source)
 230         self.assertFormatEqual(expected, actual)
 231         black.assert_equivalent(source, actual)
 232         black.assert_stable(source, actual, line_length=ll)
 233
 234     @patch("black.dump_to_file", dump_to_stderr)
 235     def test_cantfit(self) -> None:
 236         source, expected = read_data("cantfit")
 237         actual = fs(source)
 238         self.assertFormatEqual(expected, actual)
 239         black.assert_equivalent(source, actual)
 240         black.assert_stable(source, actual, line_length=ll)
 241
 242     @patch("black.dump_to_file", dump_to_stderr)
 243     def test_import_spacing(self) -> None:
 244         source, expected = read_data("import_spacing")
 245         actual = fs(source)
 246         self.assertFormatEqual(expected, actual)
 247         black.assert_equivalent(source, actual)
 248         black.assert_stable(source, actual, line_length=ll)
 249
 250     @patch("black.dump_to_file", dump_to_stderr)
 251     def test_composition(self) -> None:
 252         source, expected = read_data("composition")
 253         actual = fs(source)
 254         self.assertFormatEqual(expected, actual)
 255         black.assert_equivalent(source, actual)
 256         black.assert_stable(source, actual, line_length=ll)
 257
 258     @patch("black.dump_to_file", dump_to_stderr)
 259     def test_empty_lines(self) -> None:
 260         source, expected = read_data("empty_lines")
 261         actual = fs(source)
 262         self.assertFormatEqual(expected, actual)
 263         black.assert_equivalent(source, actual)
 264         black.assert_stable(source, actual, line_length=ll)
 265
 266     @patch("black.dump_to_file", dump_to_stderr)
 267     def test_python2(self) -> None:
 268         source, expected = read_data("python2")
 269         actual = fs(source)
 270         self.assertFormatEqual(expected, actual)
 271         # black.assert_equivalent(source, actual)
 272         black.assert_stable(source, actual, line_length=ll)
 273
 274     @patch("black.dump_to_file", dump_to_stderr)
 275     def test_fmtonoff(self) -> None:
 276         source, expected = read_data("fmtonoff")
 277         actual = fs(source)
 278         self.assertFormatEqual(expected, actual)
 279         black.assert_equivalent(source, actual)
 280         black.assert_stable(source, actual, line_length=ll)
 281
 282     def test_report(self) -> None:
 283         report = black.Report()
 284         out_lines = []
 285         err_lines = []
 286
 287         def out(msg: str, **kwargs: Any) -> None:
 288             out_lines.append(msg)
 289
 290         def err(msg: str, **kwargs: Any) -> None:
 291             err_lines.append(msg)
 292
 293         with patch("black.out", out), patch("black.err", err):
 294             report.done(Path("f1"), changed=False)
 295             self.assertEqual(len(out_lines), 1)
 296             self.assertEqual(len(err_lines), 0)
 297             self.assertEqual(out_lines[-1], "f1 already well formatted, good job.")
 298             self.assertEqual(unstyle(str(report)), "1 file left unchanged.")
 299             self.assertEqual(report.return_code, 0)
 300             report.done(Path("f2"), changed=True)
 301             self.assertEqual(len(out_lines), 2)
 302             self.assertEqual(len(err_lines), 0)
 303             self.assertEqual(out_lines[-1], "reformatted f2")
 304             self.assertEqual(
 305                 unstyle(str(report)), "1 file reformatted, 1 file left unchanged."
 306             )
 307             self.assertEqual(report.return_code, 0)
 308             report.check = True
 309             self.assertEqual(report.return_code, 1)
 310             report.check = False
 311             report.failed(Path("e1"), "boom")
 312             self.assertEqual(len(out_lines), 2)
 313             self.assertEqual(len(err_lines), 1)
 314             self.assertEqual(err_lines[-1], "error: cannot format e1: boom")
 315             self.assertEqual(
 316                 unstyle(str(report)),
 317                 "1 file reformatted, 1 file left unchanged, "
 318                 "1 file failed to reformat.",
 319             )
 320             self.assertEqual(report.return_code, 123)
 321             report.done(Path("f3"), changed=True)
 322             self.assertEqual(len(out_lines), 3)
 323             self.assertEqual(len(err_lines), 1)
 324             self.assertEqual(out_lines[-1], "reformatted f3")
 325             self.assertEqual(
 326                 unstyle(str(report)),
 327                 "2 files reformatted, 1 file left unchanged, "
 328                 "1 file failed to reformat.",
 329             )
 330             self.assertEqual(report.return_code, 123)
 331             report.failed(Path("e2"), "boom")
 332             self.assertEqual(len(out_lines), 3)
 333             self.assertEqual(len(err_lines), 2)
 334             self.assertEqual(err_lines[-1], "error: cannot format e2: boom")
 335             self.assertEqual(
 336                 unstyle(str(report)),
 337                 "2 files reformatted, 1 file left unchanged, "
 338                 "2 files failed to reformat.",
 339             )
 340             self.assertEqual(report.return_code, 123)
 341             report.done(Path("f4"), changed=False)
 342             self.assertEqual(len(out_lines), 4)
 343             self.assertEqual(len(err_lines), 2)
 344             self.assertEqual(out_lines[-1], "f4 already well formatted, good job.")
 345             self.assertEqual(
 346                 unstyle(str(report)),
 347                 "2 files reformatted, 2 files left unchanged, "
 348                 "2 files failed to reformat.",
 349             )
 350             self.assertEqual(report.return_code, 123)
 351             report.check = True
 352             self.assertEqual(
 353                 unstyle(str(report)),
 354                 "2 files would be reformatted, 2 files would be left unchanged, "
 355                 "2 files would fail to reformat.",
 356             )
 357
 358     def test_is_python36(self) -> None:
 359         node = black.lib2to3_parse("def f(*, arg): ...\n")
 360         self.assertFalse(black.is_python36(node))
 361         node = black.lib2to3_parse("def f(*, arg,): ...\n")
 362         self.assertTrue(black.is_python36(node))
 363         node = black.lib2to3_parse("def f(*, arg): f'string'\n")
 364         self.assertTrue(black.is_python36(node))
 365         source, expected = read_data("function")
 366         node = black.lib2to3_parse(source)
 367         self.assertTrue(black.is_python36(node))
 368         node = black.lib2to3_parse(expected)
 369         self.assertTrue(black.is_python36(node))
 370         source, expected = read_data("expression")
 371         node = black.lib2to3_parse(source)
 372         self.assertFalse(black.is_python36(node))
 373         node = black.lib2to3_parse(expected)
 374         self.assertFalse(black.is_python36(node))
 375
 376     def test_debug_visitor(self) -> None:
 377         source, _ = read_data("debug_visitor.py")
 378         expected, _ = read_data("debug_visitor.out")
 379         out_lines = []
 380         err_lines = []
 381
 382         def out(msg: str, **kwargs: Any) -> None:
 383             out_lines.append(msg)
 384
 385         def err(msg: str, **kwargs: Any) -> None:
 386             err_lines.append(msg)
 387
 388         with patch("black.out", out), patch("black.err", err):
 389             black.DebugVisitor.show(source)
 390         actual = "\n".join(out_lines) + "\n"
 391         log_name = ""
 392         if expected != actual:
 393             log_name = black.dump_to_file(*out_lines)
 394         self.assertEqual(
 395             expected,
 396             actual,
 397             f"AST print out is different. Actual version dumped to {log_name}",
 398         )
 399
 400     def test_format_file_contents(self) -> None:
 401         empty = ""
 402         with self.assertRaises(black.NothingChanged):
 403             black.format_file_contents(empty, line_length=ll, fast=False)
 404         just_nl = "\n"
 405         with self.assertRaises(black.NothingChanged):
 406             black.format_file_contents(just_nl, line_length=ll, fast=False)
 407         same = "l = [1, 2, 3]\n"
 408         with self.assertRaises(black.NothingChanged):
 409             black.format_file_contents(same, line_length=ll, fast=False)
 410         different = "l = [1,2,3]"
 411         expected = same
 412         actual = black.format_file_contents(different, line_length=ll, fast=False)
 413         self.assertEqual(expected, actual)
 414         invalid = "return if you can"
 415         with self.assertRaises(ValueError) as e:
 416             black.format_file_contents(invalid, line_length=ll, fast=False)
 417         self.assertEqual(str(e.exception), "Cannot parse: 1:7: return if you can")
 418
 419     def test_endmarker(self) -> None:
 420         n = black.lib2to3_parse("\n")
 421         self.assertEqual(n.type, black.syms.file_input)
 422         self.assertEqual(len(n.children), 1)
 423         self.assertEqual(n.children[0].type, black.token.ENDMARKER)
 424
 425     @unittest.skipIf(os.environ.get("SKIP_AST_PRINT"), "user set SKIP_AST_PRINT")
 426     def test_assertFormatEqual(self) -> None:
 427         out_lines = []
 428         err_lines = []
 429
 430         def out(msg: str, **kwargs: Any) -> None:
 431             out_lines.append(msg)
 432
 433         def err(msg: str, **kwargs: Any) -> None:
 434             err_lines.append(msg)
 435
 436         with patch("black.out", out), patch("black.err", err):
 437             with self.assertRaises(AssertionError):
 438                 self.assertFormatEqual("l = [1, 2, 3]", "l = [1, 2, 3,]")
 439
 440         out_str = "".join(out_lines)
 441         self.assertTrue("Expected tree:" in out_str)
 442         self.assertTrue("Actual tree:" in out_str)
 443         self.assertEqual("".join(err_lines), "")
 444
 445
 446 if __name__ == "__main__":
 447     unittest.main()