def __init__(self) -> None:
self.default_map: Dict[str, Any] = {}
+ self.params: Dict[str, Any] = {}
# Dummy root, since most of the tests don't care about it
self.obj: Dict[str, Any] = {"root": PROJECT_ROOT}
tmp_file = Path(black.dump_to_file())
try:
self.assertFalse(ff(tmp_file, write_back=black.WriteBack.YES))
- with open(tmp_file, encoding="utf8") as f:
- actual = f.read()
+ actual = tmp_file.read_text(encoding="utf-8")
finally:
os.unlink(tmp_file)
self.assertFormatEqual(expected, actual)
ff(tmp_file, mode=mode, write_back=black.WriteBack.YES)
)
with open(tmp_file, "rb") as f:
- actual = f.read().decode("utf8")
+ actual = f.read().decode("utf-8")
finally:
os.unlink(tmp_file)
self.assertFormatEqual(expected, actual)
f"--line-length={black.DEFAULT_LINE_LENGTH}",
f"--config={EMPTY_CONFIG}",
],
- input=BytesIO(source.encode("utf8")),
+ input=BytesIO(source.encode("utf-8")),
)
self.assertEqual(result.exit_code, 0)
self.assertFormatEqual(expected, result.output)
def test_piping_diff(self) -> None:
diff_header = re.compile(
- r"(STDIN|STDOUT)\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d\d\d\d "
- r"\+\d\d\d\d"
+ r"(STDIN|STDOUT)\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d\d\d\d"
+ r"\+\d\d:\d\d"
)
source, _ = read_data("simple_cases", "expression.py")
expected, _ = read_data("simple_cases", "expression.diff")
f"--config={EMPTY_CONFIG}",
]
result = BlackRunner().invoke(
- black.main, args, input=BytesIO(source.encode("utf8"))
+ black.main, args, input=BytesIO(source.encode("utf-8"))
)
self.assertEqual(result.exit_code, 0)
actual = diff_header.sub(DETERMINISTIC_HEADER, result.output)
f"--config={EMPTY_CONFIG}",
]
result = BlackRunner().invoke(
- black.main, args, input=BytesIO(source.encode("utf8"))
+ black.main, args, input=BytesIO(source.encode("utf-8"))
)
actual = result.output
# Again, the contents are checked in a different test, so only look for colors.
versions = black.detect_target_versions(root)
self.assertIn(black.TargetVersion.PY38, versions)
+ def test_pep_695_version_detection(self) -> None:
+ for file in ("type_aliases", "type_params"):
+ source, _ = read_data("py_312", file)
+ root = black.lib2to3_parse(source)
+ features = black.get_features_used(root)
+ self.assertIn(black.Feature.TYPE_PARAMS, features)
+ versions = black.detect_target_versions(root)
+ self.assertIn(black.TargetVersion.PY312, versions)
+
def test_expression_ff(self) -> None:
source, expected = read_data("simple_cases", "expression.py")
tmp_file = Path(black.dump_to_file(source))
try:
self.assertTrue(ff(tmp_file, write_back=black.WriteBack.YES))
- with open(tmp_file, encoding="utf8") as f:
- actual = f.read()
+ actual = tmp_file.read_text(encoding="utf-8")
finally:
os.unlink(tmp_file)
self.assertFormatEqual(expected, actual)
tmp_file = Path(black.dump_to_file(source))
diff_header = re.compile(
rf"{re.escape(str(tmp_file))}\t\d\d\d\d-\d\d-\d\d "
- r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d \+\d\d\d\d"
+ r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d\+\d\d:\d\d"
)
try:
result = BlackRunner().invoke(
black.main, [str(tmp_file), "-x", f"--config={EMPTY_CONFIG}"]
)
self.assertEqual(result.exit_code, 0)
- with open(tmp_file, encoding="utf8") as f:
- actual = f.read()
+ actual = tmp_file.read_text(encoding="utf-8")
self.assertFormatEqual(source, actual)
def test_skip_source_first_line_when_mixing_newlines(self) -> None:
tmp_file = Path(black.dump_to_file(source))
diff_header = re.compile(
rf"{re.escape(str(tmp_file))}\t\d\d\d\d-\d\d-\d\d "
- r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d \+\d\d\d\d"
+ r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d\+\d\d:\d\d"
)
try:
result = BlackRunner().invoke(
"pathlib.Path.cwd", return_value=working_directory
), patch("pathlib.Path.is_dir", side_effect=mock_n_calls([True])):
ctx = FakeContext()
+ # Note that the root folder (project_root) isn't the folder
+ # named "root" (aka working_directory)
ctx.obj["root"] = project_root
report = MagicMock(verbose=True)
black.get_sources(
for _, mock_args, _ in report.path_ignored.mock_calls
), "A symbolic link was reported."
report.path_ignored.assert_called_once_with(
- Path("child", "b.py"), "matches a .gitignore file content"
+ Path("root", "child", "b.py"), "matches a .gitignore file content"
)
def test_report_verbose(self) -> None:
self.assertEqual(err_lines[-1], "error: cannot format e1: boom")
self.assertEqual(
unstyle(str(report)),
- (
- "1 file reformatted, 2 files left unchanged, 1 file failed to"
- " reformat."
- ),
+ "1 file reformatted, 2 files left unchanged, 1 file failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.done(Path("f3"), black.Changed.YES)
self.assertEqual(out_lines[-1], "reformatted f3")
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 1 file failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 1 file failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.failed(Path("e2"), "boom")
self.assertEqual(err_lines[-1], "error: cannot format e2: boom")
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.path_ignored(Path("wat"), "no match")
self.assertEqual(out_lines[-1], "wat ignored: no match")
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.done(Path("f4"), black.Changed.NO)
self.assertEqual(out_lines[-1], "f4 already well formatted, good job.")
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 3 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 3 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.check = True
self.assertEqual(
unstyle(str(report)),
- (
- "2 files would be reformatted, 3 files would be left unchanged, 2"
- " files would fail to reformat."
- ),
+ "2 files would be reformatted, 3 files would be left unchanged, 2"
+ " files would fail to reformat.",
)
report.check = False
report.diff = True
self.assertEqual(
unstyle(str(report)),
- (
- "2 files would be reformatted, 3 files would be left unchanged, 2"
- " files would fail to reformat."
- ),
+ "2 files would be reformatted, 3 files would be left unchanged, 2"
+ " files would fail to reformat.",
)
def test_report_quiet(self) -> None:
self.assertEqual(err_lines[-1], "error: cannot format e1: boom")
self.assertEqual(
unstyle(str(report)),
- (
- "1 file reformatted, 2 files left unchanged, 1 file failed to"
- " reformat."
- ),
+ "1 file reformatted, 2 files left unchanged, 1 file failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.done(Path("f3"), black.Changed.YES)
self.assertEqual(len(err_lines), 1)
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 1 file failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 1 file failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.failed(Path("e2"), "boom")
self.assertEqual(err_lines[-1], "error: cannot format e2: boom")
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.path_ignored(Path("wat"), "no match")
self.assertEqual(len(err_lines), 2)
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.done(Path("f4"), black.Changed.NO)
self.assertEqual(len(err_lines), 2)
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 3 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 3 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.check = True
self.assertEqual(
unstyle(str(report)),
- (
- "2 files would be reformatted, 3 files would be left unchanged, 2"
- " files would fail to reformat."
- ),
+ "2 files would be reformatted, 3 files would be left unchanged, 2"
+ " files would fail to reformat.",
)
report.check = False
report.diff = True
self.assertEqual(
unstyle(str(report)),
- (
- "2 files would be reformatted, 3 files would be left unchanged, 2"
- " files would fail to reformat."
- ),
+ "2 files would be reformatted, 3 files would be left unchanged, 2"
+ " files would fail to reformat.",
)
def test_report_normal(self) -> None:
self.assertEqual(err_lines[-1], "error: cannot format e1: boom")
self.assertEqual(
unstyle(str(report)),
- (
- "1 file reformatted, 2 files left unchanged, 1 file failed to"
- " reformat."
- ),
+ "1 file reformatted, 2 files left unchanged, 1 file failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.done(Path("f3"), black.Changed.YES)
self.assertEqual(out_lines[-1], "reformatted f3")
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 1 file failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 1 file failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.failed(Path("e2"), "boom")
self.assertEqual(err_lines[-1], "error: cannot format e2: boom")
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.path_ignored(Path("wat"), "no match")
self.assertEqual(len(err_lines), 2)
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 2 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 2 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.done(Path("f4"), black.Changed.NO)
self.assertEqual(len(err_lines), 2)
self.assertEqual(
unstyle(str(report)),
- (
- "2 files reformatted, 3 files left unchanged, 2 files failed to"
- " reformat."
- ),
+ "2 files reformatted, 3 files left unchanged, 2 files failed to"
+ " reformat.",
)
self.assertEqual(report.return_code, 123)
report.check = True
self.assertEqual(
unstyle(str(report)),
- (
- "2 files would be reformatted, 3 files would be left unchanged, 2"
- " files would fail to reformat."
- ),
+ "2 files would be reformatted, 3 files would be left unchanged, 2"
+ " files would fail to reformat.",
)
report.check = False
report.diff = True
self.assertEqual(
unstyle(str(report)),
- (
- "2 files would be reformatted, 3 files would be left unchanged, 2"
- " files would fail to reformat."
- ),
+ "2 files would be reformatted, 3 files would be left unchanged, 2"
+ " files would fail to reformat.",
)
def test_lib2to3_parse(self) -> None:
(workspace / "one.py").resolve(),
(workspace / "two.py").resolve(),
]:
- f.write_text('print("hello")\n')
+ f.write_text('print("hello")\n', encoding="utf-8")
self.invokeBlack([str(workspace)])
@event_loop()
contents, expected = read_data("miscellaneous", "force_pyi")
with cache_dir() as workspace:
path = (workspace / "file.py").resolve()
- with open(path, "w") as fh:
- fh.write(contents)
+ path.write_text(contents, encoding="utf-8")
self.invokeBlack([str(path), "--pyi"])
- with open(path, "r") as fh:
- actual = fh.read()
+ actual = path.read_text(encoding="utf-8")
# verify cache with --pyi is separate
pyi_cache = black.read_cache(pyi_mode)
self.assertIn(str(path), pyi_cache)
(workspace / "file2.py").resolve(),
]
for path in paths:
- with open(path, "w") as fh:
- fh.write(contents)
+ path.write_text(contents, encoding="utf-8")
self.invokeBlack([str(p) for p in paths] + ["--pyi"])
for path in paths:
- with open(path, "r") as fh:
- actual = fh.read()
+ actual = path.read_text(encoding="utf-8")
self.assertEqual(actual, expected)
# verify cache with --pyi is separate
pyi_cache = black.read_cache(pyi_mode)
def test_pipe_force_pyi(self) -> None:
source, expected = read_data("miscellaneous", "force_pyi")
result = CliRunner().invoke(
- black.main, ["-", "-q", "--pyi"], input=BytesIO(source.encode("utf8"))
+ black.main, ["-", "-q", "--pyi"], input=BytesIO(source.encode("utf-8"))
)
self.assertEqual(result.exit_code, 0)
actual = result.output
source, expected = read_data("miscellaneous", "force_py36")
with cache_dir() as workspace:
path = (workspace / "file.py").resolve()
- with open(path, "w") as fh:
- fh.write(source)
+ path.write_text(source, encoding="utf-8")
self.invokeBlack([str(path), *PY36_ARGS])
- with open(path, "r") as fh:
- actual = fh.read()
+ actual = path.read_text(encoding="utf-8")
# verify cache with --target-version is separate
py36_cache = black.read_cache(py36_mode)
self.assertIn(str(path), py36_cache)
(workspace / "file2.py").resolve(),
]
for path in paths:
- with open(path, "w") as fh:
- fh.write(source)
+ path.write_text(source, encoding="utf-8")
self.invokeBlack([str(p) for p in paths] + PY36_ARGS)
for path in paths:
- with open(path, "r") as fh:
- actual = fh.read()
+ actual = path.read_text(encoding="utf-8")
self.assertEqual(actual, expected)
# verify cache with --target-version is separate
pyi_cache = black.read_cache(py36_mode)
result = CliRunner().invoke(
black.main,
["-", "-q", "--target-version=py36"],
- input=BytesIO(source.encode("utf8")),
+ input=BytesIO(source.encode("utf-8")),
)
self.assertEqual(result.exit_code, 0)
actual = result.output
contents = nl.join(["def f( ):", " pass"])
runner = BlackRunner()
result = runner.invoke(
- black.main, ["-", "--fast"], input=BytesIO(contents.encode("utf8"))
+ black.main, ["-", "--fast"], input=BytesIO(contents.encode("utf-8"))
)
self.assertEqual(result.exit_code, 0)
output = result.stdout_bytes
- self.assertIn(nl.encode("utf8"), output)
+ self.assertIn(nl.encode("utf-8"), output)
if nl == "\n":
self.assertNotIn(b"\r\n", output)
with self.assertRaises(AssertionError):
black.assert_equivalent("{}", "None")
- def test_shhh_click(self) -> None:
- try:
- from click import _unicodefun # type: ignore
- except ImportError:
- self.skipTest("Incompatible Click version")
-
- if not hasattr(_unicodefun, "_verify_python_env"):
- self.skipTest("Incompatible Click version")
-
- # First, let's see if Click is crashing with a preferred ASCII charset.
- with patch("locale.getpreferredencoding") as gpe:
- gpe.return_value = "ASCII"
- with self.assertRaises(RuntimeError):
- _unicodefun._verify_python_env()
- # Now, let's silence Click...
- black.patch_click()
- # ...and confirm it's silent.
- with patch("locale.getpreferredencoding") as gpe:
- gpe.return_value = "ASCII"
- try:
- _unicodefun._verify_python_env()
- except RuntimeError as re:
- self.fail(f"`patch_click()` failed, exception still raised: {re}")
-
def test_root_logger_not_used_directly(self) -> None:
def fail(*args: Any, **kwargs: Any) -> None:
self.fail("Record created with root logger")
for version, expected in [
("3.6", [TargetVersion.PY36]),
("3.11.0rc1", [TargetVersion.PY311]),
- (">=3.10", [TargetVersion.PY310, TargetVersion.PY311]),
- (">=3.10.6", [TargetVersion.PY310, TargetVersion.PY311]),
+ (">=3.10", [TargetVersion.PY310, TargetVersion.PY311, TargetVersion.PY312]),
+ (
+ ">=3.10.6",
+ [TargetVersion.PY310, TargetVersion.PY311, TargetVersion.PY312],
+ ),
("<3.6", [TargetVersion.PY33, TargetVersion.PY34, TargetVersion.PY35]),
(">3.7,<3.10", [TargetVersion.PY38, TargetVersion.PY39]),
- (">3.7,!=3.8,!=3.9", [TargetVersion.PY310, TargetVersion.PY311]),
+ (
+ ">3.7,!=3.8,!=3.9",
+ [TargetVersion.PY310, TargetVersion.PY311, TargetVersion.PY312],
+ ),
(
"> 3.9.4, != 3.10.3",
- [TargetVersion.PY39, TargetVersion.PY310, TargetVersion.PY311],
+ [
+ TargetVersion.PY39,
+ TargetVersion.PY310,
+ TargetVersion.PY311,
+ TargetVersion.PY312,
+ ],
),
(
"!=3.3,!=3.4",
TargetVersion.PY39,
TargetVersion.PY310,
TargetVersion.PY311,
+ TargetVersion.PY312,
],
),
(
TargetVersion.PY39,
TargetVersion.PY310,
TargetVersion.PY311,
+ TargetVersion.PY312,
],
),
("==3.8.*", [TargetVersion.PY38]),
self.assertEqual(config["exclude"], r"\.pyi?$")
self.assertEqual(config["include"], r"\.py?$")
+ def test_read_pyproject_toml_from_stdin(self) -> None:
+ with TemporaryDirectory() as workspace:
+ root = Path(workspace)
+
+ src_dir = root / "src"
+ src_dir.mkdir()
+
+ src_pyproject = src_dir / "pyproject.toml"
+ src_pyproject.touch()
+
+ test_toml_content = (THIS_DIR / "test.toml").read_text(encoding="utf-8")
+ src_pyproject.write_text(test_toml_content, encoding="utf-8")
+
+ src_python = src_dir / "foo.py"
+ src_python.touch()
+
+ fake_ctx = FakeContext()
+ fake_ctx.params["src"] = ("-",)
+ fake_ctx.params["stdin_filename"] = str(src_python)
+
+ with change_directory(root):
+ black.read_pyproject_toml(fake_ctx, FakeParameter(), None)
+
+ config = fake_ctx.default_map
+ self.assertEqual(config["verbose"], "1")
+ self.assertEqual(config["check"], "no")
+ self.assertEqual(config["diff"], "y")
+ self.assertEqual(config["color"], "True")
+ self.assertEqual(config["line_length"], "79")
+ self.assertEqual(config["target_version"], ["py36", "py37", "py38"])
+ self.assertEqual(config["exclude"], r"\.pyi?$")
+ self.assertEqual(config["include"], r"\.py?$")
+
@pytest.mark.incompatible_with_mypyc
def test_find_project_root(self) -> None:
with TemporaryDirectory() as workspace:
tmp_file = Path(black.dump_to_file(source, ensure_final_newline=False))
diff_header = re.compile(
rf"{re.escape(str(tmp_file))}\t\d\d\d\d-\d\d-\d\d "
- r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d \+\d\d\d\d"
+ r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d\+\d\d:\d\d"
)
try:
result = BlackRunner().invoke(black.main, ["--diff", str(tmp_file)])
mode = DEFAULT_MODE
with cache_dir() as workspace:
cache_file = get_cache_file(mode)
- cache_file.write_text("this is not a pickle")
+ cache_file.write_text("this is not a pickle", encoding="utf-8")
assert black.read_cache(mode) == {}
src = (workspace / "test.py").resolve()
- src.write_text("print('hello')")
+ src.write_text("print('hello')", encoding="utf-8")
invokeBlack([str(src)])
cache = black.read_cache(mode)
assert str(src) in cache
mode = DEFAULT_MODE
with cache_dir() as workspace:
src = (workspace / "test.py").resolve()
- src.write_text("print('hello')")
+ src.write_text("print('hello')", encoding="utf-8")
black.write_cache({}, [src], mode)
invokeBlack([str(src)])
- assert src.read_text() == "print('hello')"
+ assert src.read_text(encoding="utf-8") == "print('hello')"
@event_loop()
def test_cache_multiple_files(self) -> None:
"concurrent.futures.ProcessPoolExecutor", new=ThreadPoolExecutor
):
one = (workspace / "one.py").resolve()
- with one.open("w") as fobj:
- fobj.write("print('hello')")
+ one.write_text("print('hello')", encoding="utf-8")
two = (workspace / "two.py").resolve()
- with two.open("w") as fobj:
- fobj.write("print('hello')")
+ two.write_text("print('hello')", encoding="utf-8")
black.write_cache({}, [one], mode)
invokeBlack([str(workspace)])
- with one.open("r") as fobj:
- assert fobj.read() == "print('hello')"
- with two.open("r") as fobj:
- assert fobj.read() == 'print("hello")\n'
+ assert one.read_text(encoding="utf-8") == "print('hello')"
+ assert two.read_text(encoding="utf-8") == 'print("hello")\n'
cache = black.read_cache(mode)
assert str(one) in cache
assert str(two) in cache
mode = DEFAULT_MODE
with cache_dir() as workspace:
src = (workspace / "test.py").resolve()
- with src.open("w") as fobj:
- fobj.write("print('hello')")
+ src.write_text("print('hello')", encoding="utf-8")
with patch("black.read_cache") as read_cache, patch(
"black.write_cache"
) as write_cache:
with cache_dir() as workspace:
for tag in range(0, 4):
src = (workspace / f"test{tag}.py").resolve()
- with src.open("w") as fobj:
- fobj.write("print('hello')")
+ src.write_text("print('hello')", encoding="utf-8")
with patch(
"black.concurrency.Manager", wraps=multiprocessing.Manager
) as mgr:
"concurrent.futures.ProcessPoolExecutor", new=ThreadPoolExecutor
):
failing = (workspace / "failing.py").resolve()
- with failing.open("w") as fobj:
- fobj.write("not actually python")
+ failing.write_text("not actually python", encoding="utf-8")
clean = (workspace / "clean.py").resolve()
- with clean.open("w") as fobj:
- fobj.write('print("hello")\n')
+ clean.write_text('print("hello")\n', encoding="utf-8")
invokeBlack([str(workspace)], exit_code=123)
cache = black.read_cache(mode)
assert str(failing) not in cache
projects / etc / vim.git / blobdiff