import contextlib

import inspect

import os

import os.path as op

import re

import stat

import subprocess

import sys

from collections.abc import Generator

from io import StringIO

from pathlib import Path

from shutil import copyfile

from typing import Any, Optional, Union

from unittest import mock

import pytest

import codespell_lib as cs_

from codespell_lib._codespell import (

EX_CONFIG,

EX_DATAERR,

EX_OK,

EX_USAGE,

_builtin_dictionaries,

uri_regex_def,

)

def test_constants() -> None:

"""Test our EX constants."""

assert EX_OK == 0

assert EX_USAGE == 64

assert EX_DATAERR == 65

assert EX_CONFIG == 78

class MainWrapper:

"""Compatibility wrapper for when we used to return the count."""

@staticmethod

def main(

*args: Any,

count: bool = True,

std: bool = False,

) -> Union[int, tuple[int, str, str]]:

args = tuple(str(arg) for arg in args)

if count:

args = ("--count", *args)

code = cs_.main(*args)

frame = inspect.currentframe()

assert frame is not None

frame = frame.f_back

assert frame is not None

capsys = frame.f_locals["capsys"]

stdout, stderr = capsys.readouterr()

assert code in (EX_OK, EX_USAGE, EX_DATAERR, EX_CONFIG)

if code == EX_DATAERR: # have some misspellings

code = int(stderr.split("\n")[-2])

elif code == EX_OK and count:

code = int(stderr.split("\n")[-2])

assert code == 0

if std:

return (code, stdout, stderr)

return code

cs = MainWrapper()

def run_codespell(

args: tuple[Any, ...] = (),

cwd: Optional[Path] = None,

) -> int:

"""Run codespell."""

args = tuple(str(arg) for arg in args)

proc = subprocess.run( # noqa: S603

["codespell", "--count", *args], # noqa: S607

cwd=cwd,

capture_output=True,

encoding="utf-8",

check=False,

)

return int(proc.stderr.split("\n")[-2])

def test_command(tmp_path: Path) -> None:

"""Test running the codespell executable."""

# With no arguments does "."

assert run_codespell(cwd=tmp_path) == 0

(tmp_path / "bad.txt").write_text("abandonned\nAbandonned\nABANDONNED\nAbAnDoNnEd")

assert run_codespell(cwd=tmp_path) == 4

def test_basic(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test some basic functionality."""

assert cs.main("_does_not_exist_") == 0

fname = tmp_path / "tmp"

fname.touch()

result = cs.main("-D", "foo", fname, std=True)

assert isinstance(result, tuple)

code, _, stderr = result

assert code == EX_USAGE, "missing dictionary"

assert "cannot find dictionary" in stderr

assert cs.main(fname) == 0, "empty file"

with fname.open("a") as f:

f.write("this is a test file\n")

assert cs.main(fname) == 0, "good"

with fname.open("a") as f:

f.write("abandonned\n")

assert cs.main(fname) == 1, "bad"

with fname.open("a") as f:

f.write("abandonned\n")

assert cs.main(fname) == 2, "worse"

with fname.open("a") as f:

f.write("tim\ngonna\n")

assert cs.main(fname) == 2, "with a name"

assert cs.main("--builtin", "clear,rare,names,informal", fname) == 4

assert cs.main("--builtin", "all", fname) == cs.main(

"--builtin",

",".join(d[0] for d in _builtin_dictionaries),

fname,

)

with fname.open("w") as f: # overwrite the file

f.write("var = 'nwe must check codespell likes escapes nin strings'\n")

assert cs.main(fname) == 1, "checking our string escape test word is bad"

# the first one is missed because the apostrophe means its not currently

# treated as a word on its own

with fname.open("w") as f: # overwrite the file

f.write("var = '\\nwe must check codespell likes escapes \\nin strings'\n")

assert cs.main(fname) == 0, "with string escape"

result = cs.main(fname, "--builtin", "foo", std=True)

assert isinstance(result, tuple)

code, _, stderr = result

assert code == EX_USAGE # bad type

assert "Unknown builtin dictionary" in stderr

result = cs.main(fname, "-D", tmp_path / "foo", std=True)

assert isinstance(result, tuple)

code, _, stderr = result

assert code == EX_USAGE # bad dict

assert "cannot find dictionary" in stderr

fname.unlink()

with (tmp_path / "bad.txt").open("w", newline="") as f:

f.write(

"abandonned\nAbandonned\nABANDONNED\nAbAnDoNnEd\nabandonned\rAbandonned\r\nABANDONNED \n AbAnDoNnEd" # noqa: E501

)

assert cs.main(tmp_path) == 8

result = cs.main("-w", tmp_path, std=True)

assert isinstance(result, tuple)

code, _, stderr = result

assert code == 0

assert "FIXED:" in stderr

with (tmp_path / "bad.txt").open(newline="") as f:

new_content = f.read()

assert cs.main(tmp_path) == 0

assert (

new_content

== "abandoned\nAbandoned\nABANDONED\nabandoned\nabandoned\rAbandoned\r\nABANDONED \n abandoned" # noqa: E501

)

(tmp_path / "bad.txt").write_text("abandonned abandonned\n")

assert cs.main(tmp_path) == 2

result = cs.main("-q", "16", "-w", tmp_path, count=False, std=True)

assert isinstance(result, tuple)

code, stdout, stderr = result

assert code == 0

assert not stdout

assert not stderr

assert cs.main(tmp_path) == 0

# empty directory

(tmp_path / "empty").mkdir()

assert cs.main(tmp_path) == 0

def test_write_changes_keeps_original_if_replace_fails(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

monkeypatch: pytest.MonkeyPatch,

) -> None:

"""An interrupted --write-changes must not empty the original file."""

fname = tmp_path / "a.txt"

original = "this file has an abandonned word\n"

fname.write_text(original)

def fail_replace(src: str, dst: str) -> None:

raise InterruptedError

monkeypatch.setattr(os, "replace", fail_replace)

with pytest.raises(InterruptedError):

cs.main("-q", "16", "-w", fname)

assert fname.read_text() == original

assert list(tmp_path.glob(".codespell-*.tmp")) == []

@pytest.mark.skipif(sys.platform == "win32", reason="POSIX permission bits")

def test_write_changes_preserves_file_mode(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Atomic --write-changes must not reset the original file mode."""

fname = tmp_path / "a.txt"

fname.write_text("this file has an abandonned word\n")

fname.chmod(0o640)

assert cs.main("-q", "16", "-w", fname) == 0

assert fname.read_text() == "this file has an abandoned word\n"

assert stat.S_IMODE(fname.stat().st_mode) == 0o640

@pytest.mark.skipif(sys.platform == "win32", reason="symlinks need privileges")

def test_write_changes_follows_symlink(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Atomic --write-changes must update a symlink's target, not the link."""

target = tmp_path / "real.txt"

target.write_text("this file has an abandonned word\n")

link = tmp_path / "link.txt"

link.symlink_to(target.name)

assert cs.main("-q", "16", "-w", link) == 0

assert link.is_symlink()

assert target.read_text() == "this file has an abandoned word\n"

def test_write_changes_lists_changes(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test that -w flag shows list of changes made to file."""

fname = tmp_path / "misspelled.txt"

fname.write_text("This is abandonned\nAnd this is occured\nAlso teh typo\n")

result = cs.main("-w", fname, std=True)

assert isinstance(result, tuple)

code, _, stderr = result

assert code == 0

assert "FIXED:" in stderr

# Check that changes are listed with format: filename:line: wrong ==> right

assert "misspelled.txt:1: abandonned ==> abandoned" in stderr

assert "misspelled.txt:2: occured ==> occurred" in stderr

assert "misspelled.txt:3: teh ==> the" in stderr

corrected = fname.read_text()

assert corrected == "This is abandoned\nAnd this is occurred\nAlso the typo\n"

def test_default_word_parsing(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

fname = tmp_path / "backtick"

with fname.open("a") as f:

f.write("`abandonned`\n")

assert cs.main(fname) == 1, "bad"

fname = tmp_path / "apostrophe"

fname.write_text("woudn't\n", encoding="utf-8") # U+0027

assert cs.main(fname) == 1, "misspelling containing typewriter apostrophe U+0027"

fname.write_text("woudn’t\n", encoding="utf-8") # U+2019 # noqa: RUF001

assert cs.main(fname) == 1, "misspelling containing typographic apostrophe U+2019"

def test_bad_glob(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

# disregard invalid globs, properly handle escaped globs

g = tmp_path / "glob"

g.mkdir()

fname = g / "[b-a].txt"

fname.write_text("abandonned\n")

assert cs.main(g) == 1

# bad glob is invalid

result = cs.main("--skip", "[b-a].txt", g, std=True)

assert isinstance(result, tuple)

code, _, stderr = result

if sys.hexversion < 0x030A05F0: # Python < 3.10.5 raises re.error

assert code == EX_USAGE, "invalid glob"

assert "invalid glob" in stderr

else: # Python >= 3.10.5 does not match

assert code == 1

# properly escaped glob is valid, and matches glob-like file name

assert cs.main("--skip", "[[]b-a[]].txt", g) == 0

@pytest.mark.skipif(sys.platform != "linux", reason="Only supported on Linux")

def test_permission_error(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test permission error handling."""

fname = tmp_path / "unreadable.txt"

fname.write_text("abandonned\n")

result = cs.main(fname, std=True)

assert isinstance(result, tuple)

_, _, stderr = result

assert "WARNING:" not in stderr

fname.chmod(0o000)

result = cs.main(fname, std=True)

assert isinstance(result, tuple)

_, _, stderr = result

assert "WARNING:" in stderr

def test_interactivity(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test interaction"""

# Windows can't read a currently-opened file, so here we use

# NamedTemporaryFile just to get a good name

fname = tmp_path / "tmp"

fname.touch()

try:

assert cs.main(fname) == 0, "empty file"

fname.write_text("abandonned\n")

with mock.patch.object(sys, "argv", ("-i", "-1", fname)):

with pytest.raises(SystemExit) as e:

cs.main("-i", "-1", fname)

assert e.type is SystemExit

assert e.value.code != 0

with FakeStdin("n\n"):

result = cs.main("-w", "-i", "3", fname, std=True)

assert isinstance(result, tuple)

code, stdout, _ = result

assert code == 0

assert "==>" in stdout

with FakeStdin("x\ny\n"):

assert cs.main("-w", "-i", "3", fname) == 0

assert cs.main(fname) == 0

finally:

fname.unlink()

# New example

fname = tmp_path / "tmp2"

fname.write_text("abandonned\n")

try:

assert cs.main(fname) == 1

with FakeStdin(" "): # blank input -> Y

assert cs.main("-w", "-i", "3", fname) == 0

assert cs.main(fname) == 0

finally:

fname.unlink()

# multiple options

fname = tmp_path / "tmp3"

fname.write_text("ackward\n")

try:

assert cs.main(fname) == 1

with FakeStdin(" \n"): # blank input -> nothing

assert cs.main("-w", "-i", "3", fname) == 0

assert cs.main(fname) == 1

with FakeStdin("0\n"): # blank input -> nothing

assert cs.main("-w", "-i", "3", fname) == 0

assert cs.main(fname) == 0

assert fname.read_text() == "awkward\n"

fname.write_text("ackward\n")

assert cs.main(fname) == 1

with FakeStdin("x\n1\n"): # blank input -> nothing

result = cs.main("-w", "-i", "3", fname, std=True)

assert isinstance(result, tuple)

code, stdout, _ = result

assert code == 0

assert "a valid option" in stdout

assert cs.main(fname) == 0

assert fname.read_text() == "backward\n"

finally:

fname.unlink()

def test_summary(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test summary functionality."""

fname = tmp_path / "tmp"

fname.touch()

result = cs.main(fname, std=True, count=False)

assert isinstance(result, tuple)

code, stdout, stderr = result

assert code == 0

assert not stdout

assert not stderr, "no output"

result = cs.main(fname, "--summary", std=True)

assert isinstance(result, tuple)

code, stdout, stderr = result

assert code == 0

assert stderr == "0\n"

assert "SUMMARY" in stdout

assert len(stdout.split("\n")) == 5

fname.write_text("abandonned\nabandonned")

assert code == 0

result = cs.main(fname, "--summary", std=True)

assert isinstance(result, tuple)

code, stdout, stderr = result

assert stderr == "2\n"

assert "SUMMARY" in stdout

assert len(stdout.split("\n")) == 7

assert "abandonned" in stdout.split()[-2]

def test_ignore_dictionary(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test ignore dictionary functionality."""

bad_name = tmp_path / "bad.txt"

bad_name.write_text(

"1 abandonned 1\n"

"2 abandonned 2\n"

"3 abandonned 3\r\n"

"4 abilty 4\n"

"5 abilty 5\n"

"6 abilty 6\r\n"

"7 ackward 7\n"

"8 ackward 8\n"

"9 ackward 9\r\n"

"abondon\n"

)

assert cs.main(bad_name) == 10

fname = tmp_path / "ignore.txt"

fname.write_text("abandonned\nabilty\r\nackward")

assert cs.main("-I", fname, bad_name) == 1

# missing file in ignore list

fname_missing = tmp_path / "missing.txt"

result = cs.main("-I", fname_missing, bad_name, std=True)

assert isinstance(result, tuple)

code, _, stderr = result

assert code == EX_USAGE

assert "ERROR:" in stderr

# comma-separated list of files

fname_dummy1 = tmp_path / "dummy1.txt"

fname_dummy1.touch()

fname_dummy2 = tmp_path / "dummy2.txt"

fname_dummy2.touch()

assert cs.main("-I", fname_dummy1, "-I", fname, "-I", fname_dummy2, bad_name) == 1

assert cs.main("-I", f"{fname_dummy1},{fname},{fname_dummy2}", bad_name) == 1

def test_ignore_words_with_cases(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test case-sensitivity implemented for -I and -L options in #3272."""

bad_name = tmp_path / "MIS.txt"

bad_name.write_text(

"1 MIS (Management Information System) 1\n2 Les Mis (1980 musical) 2\n3 mis 3\n"

)

assert cs.main(bad_name) == 3

assert cs.main(bad_name, "-f") == 4

fname = tmp_path / "ignore.txt"

fname.write_text("miS")

assert cs.main("-I", fname, bad_name) == 3

assert cs.main("-LmiS", bad_name) == 3

assert cs.main("-I", fname, "-f", bad_name) == 4

assert cs.main("-LmiS", "-f", bad_name) == 4

fname.write_text("MIS")

assert cs.main("-I", fname, bad_name) == 2

assert cs.main("-LMIS", bad_name) == 2

assert cs.main("-I", fname, "-f", bad_name) == 2

assert cs.main("-LMIS", "-f", bad_name) == 2

fname.write_text("MIS\nMis")

assert cs.main("-I", fname, bad_name) == 1

assert cs.main("-LMIS,Mis", bad_name) == 1

assert cs.main("-I", fname, "-f", bad_name) == 1

assert cs.main("-LMIS,Mis", "-f", bad_name) == 1

fname.write_text("mis")

assert cs.main("-I", fname, bad_name) == 0

assert cs.main("-Lmis", bad_name) == 0

assert cs.main("-I", fname, "-f", bad_name) == 0

assert cs.main("-Lmis", "-f", bad_name) == 0

def test_ignore_word_list(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test ignore word list functionality."""

(tmp_path / "bad.txt").write_text("abandonned\nabondon\nabilty\n")

assert cs.main(tmp_path) == 3

assert cs.main("-Labandonned,someword", "-Labilty", tmp_path) == 1

@pytest.mark.parametrize(

("content", "expected_error_count"),

[

# recommended form

("abandonned abondon abilty # codespell:ignore abondon", 2),

("abandonned abondon abilty // codespell:ignore abondon,abilty", 1),

(

"abandonned abondon abilty /* codespell:ignore abandonned,abondon,abilty",

0,

),

# ignore unused ignore

("abandonned abondon abilty # codespell:ignore nomenklatur", 3),

# wildcard form

("abandonned abondon abilty # codespell:ignore ", 0),

("abandonned abondon abilty # codespell:ignore", 0),

("abandonned abondon abilty # codespell:ignore\n", 0),

("abandonned abondon abilty # codespell:ignore\r\n", 0),

("abandonned abondon abilty # codespell:ignore # noqa: E501\n", 0),

("abandonned abondon abilty # codespell:ignore # noqa: E501\n", 0),

("abandonned abondon abilty # codespell:ignore# noqa: E501\n", 0),

("abandonned abondon abilty # codespell:ignore, noqa: E501\n", 0),

("abandonned abondon abilty #codespell:ignore\n", 0),

# ignore these for safety

("abandonned abondon abilty # codespell:ignorenoqa: E501\n", 3),

("abandonned abondon abilty codespell:ignore\n", 3),

("abandonned abondon abilty codespell:ignore\n", 3),

# ignore these as they aren't valid

("abandonned abondon abilty # codespell:igore\n", 4),

# showcase different comment markers

("abandonned abondon abilty ' codespell:ignore\n", 0),

('abandonned abondon abilty " codespell:ignore\n', 0),

("abandonned abondon abilty ;; codespell:ignore\n", 0),

("abandonned abondon abilty /* codespell:ignore */\n", 0),

# prose examples

(

"You could also use line based igore ( codespell:ignore ) to igore ",

0,

),

("You could also use line based igore (codespell:ignore) to igore ", 0),

(

"You could also use line based igore (codespell:ignore igore) to igore ",

0,

),

(

"You could also use line based igore (codespell:ignore igare) to igore ",

2,

),

],

)

def test_inline_ignores(

tmpdir: pytest.TempPathFactory,

capsys: pytest.CaptureFixture[str],

content: str,

expected_error_count: int,

) -> None:

d = str(tmpdir)

with open(op.join(d, "bad.txt"), "w", encoding="utf-8") as f:

f.write(content)

assert cs.main(d) == expected_error_count

@pytest.mark.parametrize(

("content", "expected_error_count"),

[

# marker right after the word (optional whitespace) excuses it

("they wrod [sic] it\n", 0),

("they wrod[sic] it\n", 0),

("they wrod [sic] it\n", 0),

# case-insensitive marker

("they wrod [SIC] it\n", 0),

# quoted typo followed by the marker (changelog use case)

('correct "wrod" [sic] typo\n', 0),

('correct "wrod"[sic] typo\n', 0),

# only the immediately preceding occurrence is excused

("wrod wrod [sic]\n", 1),

# a marker elsewhere on the line does not excuse the word

("wrod it [sic] anyway abilty\n", 2),

# an intervening word breaks the association

('wrod" abilty [sic]\n', 1),

# without a marker the misspelling is still reported

("they wrod it\n", 1),

# not a real marker

("they wrod (sic) it\n", 1),

("they wrod [sick] it\n", 1),

],

)

def test_ignore_sic(

tmpdir: pytest.TempPathFactory,

capsys: pytest.CaptureFixture[str],

content: str,

expected_error_count: int,

) -> None:

d = str(tmpdir)

with open(op.join(d, "bad.txt"), "w", encoding="utf-8") as f:

f.write(content)

# off by default

assert cs.main(d) == content.count("wrod") + content.count("abilty")

# opt-in

assert cs.main("--ignore-sic", d) == expected_error_count

@pytest.mark.parametrize(

("content", "expected_error_count"),

[

# wildcard form: ignore all misspellings on the next line

("# codespell:ignore-next-line\nabandonned abondon abilty\n", 0),

("// codespell:ignore-next-line\nabandonned abondon abilty\n", 0),

# specific word form: ignore only listed words on the next line

(

"# codespell:ignore-next-line abondon\nabandonned abondon abilty\n",

2,

),

(

"# codespell:ignore-next-line abondon,abilty\nabandonned abondon abilty\n",

1,

),

# the directive does not affect the line it is on or subsequent lines

(

"abandonned # codespell:ignore-next-line\nabondon\nabilty\n",

2,

),

# listing an unused ignore word still triggers a skip

(

"# codespell:ignore-next-line nomenklatur\nabandonned abondon abilty\n",

3,

),

# invalid directives are not honored

("# codespell:ignore-next-lin\nabandonned\n", 1),

("codespell:ignore-next-line\nabandonned\n", 1),

# directive followed by a blank line still consumes the directive

("# codespell:ignore-next-line\n\nabandonned\n", 1),

],

)

def test_ignore_next_line(

tmpdir: pytest.TempPathFactory,

capsys: pytest.CaptureFixture[str],

content: str,

expected_error_count: int,

) -> None:

d = str(tmpdir)

with open(op.join(d, "bad.txt"), "w", encoding="utf-8") as f:

f.write(content)

assert cs.main(d) == expected_error_count

def test_custom_regex(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test custom word regex."""

(tmp_path / "bad.txt").write_text("abandonned_abondon\n")

assert cs.main(tmp_path) == 0

assert cs.main("-r", "[a-z]+", tmp_path) == 2

result = cs.main("-r", "[a-z]+", "--write-changes", tmp_path, std=True)

assert isinstance(result, tuple)

code, _, stderr = result

assert code == EX_USAGE

assert "ERROR:" in stderr

def test_exclude_file(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test exclude file functionality."""

bad_name = tmp_path / "bad.txt"

# check all possible combinations of lines to ignore and ignores

combinations = "".join(

f"{n} abandonned {n}\n"

f"{n} abandonned {n}\r\n"

f"{n} abandonned {n} \n"

f"{n} abandonned {n} \r\n"

for n in range(1, 5)

)

bad_name.write_bytes(

(combinations + "5 abandonned 5\n6 abandonned 6").encode("utf-8")

)

assert cs.main(bad_name) == 18

fname = tmp_path / "tmp.txt"

fname.write_bytes(

b"1 abandonned 1\n"

b"2 abandonned 2\r\n"

b"3 abandonned 3 \n"

b"4 abandonned 4 \r\n"

b"6 abandonned 6\n"

)

assert cs.main(bad_name) == 18

assert cs.main("-x", fname, bad_name) == 1

# comma-separated list of files

fname_dummy1 = tmp_path / "dummy1.txt"

fname_dummy1.touch()

fname_dummy2 = tmp_path / "dummy2.txt"

fname_dummy2.touch()

assert cs.main("-x", fname_dummy1, "-x", fname, "-x", fname_dummy2, bad_name) == 1

assert cs.main("-x", f"{fname_dummy1},{fname},{fname_dummy2}", bad_name) == 1

def test_encoding(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test encoding handling."""

# Some simple Unicode things

fname = tmp_path / "tmp"

fname.touch()

# with CaptureStdout() as sio:

assert cs.main(fname) == 0

fname.write_bytes("naïve\n".encode())

assert cs.main(fname) == 0

assert cs.main("-e", fname) == 0

with fname.open("ab") as f:

f.write(b"naieve\n")

assert cs.main(fname) == 1

# Encoding detection (only try ISO 8859-1 because UTF-8 is the default)

fname.write_bytes(b"Speling error, non-ASCII: h\xe9t\xe9rog\xe9n\xe9it\xe9\n")

# check warnings about wrong encoding are enabled with "-q 0"

result = cs.main("-q", "0", fname, std=True, count=True)

assert isinstance(result, tuple)

code, stdout, stderr = result

assert code == 1

assert "Speling" in stdout

assert "iso-8859-1" in stderr

# check warnings about wrong encoding are disabled with "-q 1"

result = cs.main("-q", "1", fname, std=True, count=True)

assert isinstance(result, tuple)

code, stdout, stderr = result

assert code == 1

assert "Speling" in stdout

assert "iso-8859-1" not in stderr

# Binary file warning

fname.write_bytes(b"\x00\x00naiive\x00\x00")

result = cs.main(fname, std=True, count=False)

assert isinstance(result, tuple)

code, stdout, stderr = result

assert code == 0

assert not stdout

assert not stderr

result = cs.main("-q", "0", fname, std=True, count=False)

assert isinstance(result, tuple)

code, stdout, stderr = result

assert code == 0

assert not stdout

assert "WARNING: Binary file" in stderr

def test_unknown_encoding_chardet(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test opening a file with unknown encoding using chardet"""

fname = tmp_path / "tmp"

fname.touch()

assert cs.main("--hard-encoding-detection", fname) == 0

def test_ignore(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test ignoring of files and directories."""

goodtxt = tmp_path / "good.txt"

goodtxt.write_text("this file is okay")

assert cs.main(tmp_path) == 0

badtxt = tmp_path / "bad.txt"

badtxt.write_text("abandonned")

assert cs.main(tmp_path) == 1

assert cs.main("--skip=bad*", tmp_path) == 0

assert cs.main("--skip=bad.txt", tmp_path) == 0

subdir = tmp_path / "ignoredir"

subdir.mkdir()

(subdir / "bad.txt").write_text("abandonned")

assert cs.main(tmp_path) == 2

assert cs.main("--skip=bad*", tmp_path) == 0

assert cs.main("--skip=whatever.txt,bad*,whatelse.txt", tmp_path) == 0

assert cs.main("--skip=whatever.txt,\n bad* ,", tmp_path) == 0

assert cs.main("--skip=*ignoredir*", tmp_path) == 1

assert cs.main("--skip=ignoredir", tmp_path) == 1

assert cs.main("--skip=*ignoredir/bad*", tmp_path) == 1

assert cs.main(f"--skip={tmp_path}", tmp_path) == 0

badjs = tmp_path / "bad.js"

copyfile(badtxt, badjs)

assert cs.main("--skip=*.js", goodtxt, badtxt, badjs) == 1

def test_check_filename(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test filename check."""

fname = tmp_path / "abandonned.txt"

# Empty file

fname.touch()

assert cs.main("-f", tmp_path) == 1

# Normal file with contents

fname.write_text(".")

assert cs.main("-f", tmp_path) == 1

# Normal file with binary contents

fname.write_bytes(b"\x00\x00naiive\x00\x00")

assert cs.main("-f", tmp_path) == 1

@pytest.mark.skipif(

(not hasattr(os, "mkfifo") or not callable(os.mkfifo)), reason="requires os.mkfifo"

)

def test_check_filename_irregular_file(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test irregular file filename check."""

# Irregular file (!isfile())

os.mkfifo(tmp_path / "abandonned")

assert cs.main("-f", tmp_path) == 1

def test_check_hidden(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test ignoring of hidden files."""

# visible file

#

# tmp_path

# └── test.txt

#

fname = tmp_path / "test.txt"

fname.write_text("erorr\n")

assert cs.main(fname) == 1

assert cs.main(tmp_path) == 1

# hidden file

#

# tmp_path

# └── .test.txt

#

hidden_file = tmp_path / ".test.txt"

fname.rename(hidden_file)

assert cs.main(hidden_file) == 0

assert cs.main(tmp_path) == 0

assert cs.main("--check-hidden", hidden_file) == 1

assert cs.main("--check-hidden", tmp_path) == 1

# hidden file with typo in name

#

# tmp_path

# └── .abandonned.txt

#

typo_file = tmp_path / ".abandonned.txt"

hidden_file.rename(typo_file)

assert cs.main(typo_file) == 0

assert cs.main(tmp_path) == 0

assert cs.main("--check-hidden", typo_file) == 1

assert cs.main("--check-hidden", tmp_path) == 1

assert cs.main("--check-hidden", "--check-filenames", typo_file) == 2

assert cs.main("--check-hidden", "--check-filenames", tmp_path) == 2

# hidden directory

#

# tmp_path

# ├── .abandonned

# │ ├── .abandonned.txt

# │ └── subdir

# │ └── .abandonned.txt

# └── .abandonned.txt

#

assert cs.main(tmp_path) == 0

assert cs.main("--check-hidden", tmp_path) == 1

assert cs.main("--check-hidden", "--check-filenames", tmp_path) == 2

hidden = tmp_path / ".abandonned"

hidden.mkdir()

copyfile(typo_file, hidden / typo_file.name)

subdir = hidden / "subdir"

subdir.mkdir()

copyfile(typo_file, subdir / typo_file.name)

assert cs.main(tmp_path) == 0

assert cs.main("--check-hidden", tmp_path) == 3

assert cs.main("--check-hidden", "--check-filenames", tmp_path) == 8

# check again with a relative path

try:

rel = op.relpath(tmp_path)

except ValueError:

# Windows: path is on mount 'C:', start on mount 'D:'

pass

else:

assert cs.main(rel) == 0

assert cs.main("--check-hidden", rel) == 3

assert cs.main("--check-hidden", "--check-filenames", rel) == 8

# hidden subdirectory

#

# tmp_path

# ├── .abandonned

# │ ├── .abandonned.txt

# │ └── subdir

# │ └── .abandonned.txt

# ├── .abandonned.txt

# └── subdir

# └── .abandonned

# └── .abandonned.txt

subdir = tmp_path / "subdir"

subdir.mkdir()

hidden = subdir / ".abandonned"

hidden.mkdir()

copyfile(typo_file, hidden / typo_file.name)

assert cs.main(tmp_path) == 0

assert cs.main("--check-hidden", tmp_path) == 4

assert cs.main("--check-hidden", "--check-filenames", tmp_path) == 11

def test_case_handling(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test that capitalized entries get detected properly."""

# Some simple Unicode things

fname = tmp_path / "tmp"

fname.touch()

# with CaptureStdout() as sio:

assert cs.main(fname) == 0

fname.write_bytes(b"this has an ACII error")

result = cs.main(fname, std=True)

assert isinstance(result, tuple)

code, stdout, _ = result

assert code == 1

assert "ASCII" in stdout

result = cs.main("-w", fname, std=True)

assert isinstance(result, tuple)

code, _, stderr = result

assert code == 0

assert "FIXED" in stderr

assert fname.read_text(encoding="utf-8") == "this has an ASCII error"

def _helper_test_case_handling_in_fixes(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

reason: bool,

) -> None:

dictionary_name = tmp_path / "dictionary.txt"

if reason:

dictionary_name.write_text("adoptor->adopter, adaptor, reason\n")

else:

dictionary_name.write_text("adoptor->adopter, adaptor,\n")

# the misspelled word is entirely lowercase

fname = tmp_path / "bad.txt"

fname.write_text("early adoptor\n")

result = cs.main("-D", dictionary_name, fname, std=True)

assert isinstance(result, tuple)

_, stdout, _ = result

# all suggested fixes must be lowercase too

assert "adopter, adaptor" in stdout

# the reason, if any, must not be modified

if reason:

assert "reason" in stdout

# the misspelled word is capitalized

fname.write_text("Early Adoptor\n")

result = cs.main("-D", dictionary_name, fname, std=True)

assert isinstance(result, tuple)

_, stdout, _ = result

# all suggested fixes must be capitalized too

assert "Adopter, Adaptor" in stdout

# the reason, if any, must not be modified

if reason:

assert "reason" in stdout

# the misspelled word is entirely uppercase

fname.write_text("EARLY ADOPTOR\n")

result = cs.main("-D", dictionary_name, fname, std=True)

assert isinstance(result, tuple)

_, stdout, _ = result

# all suggested fixes must be uppercase too

assert "ADOPTER, ADAPTOR" in stdout

# the reason, if any, must not be modified

if reason:

assert "reason" in stdout

# the misspelled word mixes lowercase and uppercase

fname.write_text("EaRlY AdOpToR\n")

result = cs.main("-D", dictionary_name, fname, std=True)

assert isinstance(result, tuple)

_, stdout, _ = result

# all suggested fixes should be lowercase

assert "adopter, adaptor" in stdout

# the reason, if any, must not be modified

if reason:

assert "reason" in stdout

def test_case_handling_in_fixes(

tmp_path: Path, capsys: pytest.CaptureFixture[str]

) -> None:

"""Test that the case of fixes is similar to the misspelled word."""

_helper_test_case_handling_in_fixes(tmp_path, capsys, reason=False)

_helper_test_case_handling_in_fixes(tmp_path, capsys, reason=True)

def test_context(

tmp_path: Path,

capsys: pytest.CaptureFixture[str],

) -> None:

"""Test context options."""

(tmp_path / "context.txt").write_text(

"line 1\nline 2\nline 3 abandonned\nline 4\nline 5"

)

# symmetric context, fully within file

result = cs.main("-C", "1", tmp_path, std=True)

assert isinstance(result, tuple)

code, stdout, _ = result