tests/test_cli.py - third_party/github.com/hukkin/mdformat - Git at Google

 import os
 import sys
 from unittest.mock import patch

 import pytest

 import mdformat
 from mdformat._cli import get_plugin_info_str, run, wrap_paragraphs
 from mdformat.plugins import CODEFORMATTERS, PARSER_EXTENSIONS
 from tests.utils import (
     FORMATTED_MARKDOWN,
     UNFORMATTED_MARKDOWN,
     ASTChangingPlugin,
     PrefixPostprocessPlugin,
 )


 def test_no_files_passed():
     assert run(()) == 0


 def test_format(tmp_path):
     file_path = tmp_path / "test_markdown.md"
     file_path.write_text(UNFORMATTED_MARKDOWN)
     assert run((str(file_path),)) == 0
     assert file_path.read_text() == FORMATTED_MARKDOWN


 def test_format__folder(tmp_path):
     file_path_1 = tmp_path / "test_markdown1.md"
     file_path_2 = tmp_path / "test_markdown2.md"
     file_path_3 = tmp_path / "not_markdown3"
     file_path_1.write_text(UNFORMATTED_MARKDOWN)
     file_path_2.write_text(UNFORMATTED_MARKDOWN)
     file_path_3.write_text(UNFORMATTED_MARKDOWN)
     assert run((str(tmp_path),)) == 0
     assert file_path_1.read_text() == FORMATTED_MARKDOWN
     assert file_path_2.read_text() == FORMATTED_MARKDOWN
     assert file_path_3.read_text() == UNFORMATTED_MARKDOWN


 def test_format__folder_leads_to_invalid(tmp_path):
     file_path_1 = tmp_path / "test_markdown1.md"
     file_path_1.mkdir()
     assert run((str(tmp_path),)) == 0
     assert file_path_1.is_dir()


 def test_format__symlinks(tmp_path):
     # Create two MD files
     file_path_1 = tmp_path / "test_markdown1.md"
     file_path_2 = tmp_path / "test_markdown2.md"
     file_path_1.write_text(UNFORMATTED_MARKDOWN)
     file_path_2.write_text(UNFORMATTED_MARKDOWN)

     # Create a symlink to both files: one in the root folder, one in a sub folder
     subdir_path = tmp_path / "subdir"
     subdir_path.mkdir()
     symlink_1 = subdir_path / "symlink1.md"
     symlink_1.symlink_to(file_path_1)
     symlink_2 = tmp_path / "symlink2.md"
     symlink_2.symlink_to(file_path_2)

     # Format file 1 via directory of the symlink, and file 2 via symlink
     assert run([str(subdir_path), str(symlink_2)]) == 0

     # Assert that files are formatted and symlinks are not overwritten
     assert file_path_1.read_text() == FORMATTED_MARKDOWN
     assert file_path_2.read_text() == FORMATTED_MARKDOWN
     assert symlink_1.is_symlink()
     assert symlink_2.is_symlink()


 def test_broken_symlink(tmp_path, capsys):
     # Create a broken symlink
     file_path = tmp_path / "test_markdown1.md"
     symlink_path = tmp_path / "symlink"
     symlink_path.symlink_to(file_path)

     with pytest.raises(SystemExit) as exc_info:
         run([str(symlink_path)])
     assert exc_info.value.code == 2
     captured = capsys.readouterr()
     assert "does not exist" in captured.err


 def test_invalid_file(capsys):
     with pytest.raises(SystemExit) as exc_info:
         run(("this is not a valid filepath?`=|><@{[]\\/,.%¤#'",))
     assert exc_info.value.code == 2
     captured = capsys.readouterr()
     assert "does not exist" in captured.err


 @pytest.mark.skipif(os.name == "nt", reason="No os.mkfifo on windows")
 def test_fifo(tmp_path, capsys):
     fifo_path = tmp_path / "fifo1"
     os.mkfifo(fifo_path)
     with pytest.raises(SystemExit) as exc_info:
         run((str(fifo_path),))
     assert exc_info.value.code == 2
     assert "does not exist" in capsys.readouterr().err


 def test_check(tmp_path):
     file_path = tmp_path / "test_markdown.md"
     file_path.write_bytes(FORMATTED_MARKDOWN.encode())
     assert run((str(file_path), "--check")) == 0


 def test_check__fail(tmp_path):
     file_path = tmp_path / "test_markdown.md"
     file_path.write_text(UNFORMATTED_MARKDOWN)
     assert run((str(file_path), "--check")) == 1


 def test_check__multi_fail(capsys, tmp_path):
     """Test for --check flag when multiple files are unformatted.

     Test that the names of all unformatted files are listed when using
     --check.
     """
     file_path1 = tmp_path / "test_markdown1.md"
     file_path2 = tmp_path / "test_markdown2.md"
     file_path1.write_text(UNFORMATTED_MARKDOWN)
     file_path2.write_text(UNFORMATTED_MARKDOWN)
     assert run((str(tmp_path), "--check")) == 1
     captured = capsys.readouterr()
     assert str(file_path1) in captured.err
     assert str(file_path2) in captured.err


 def example_formatter(code, info):
     return "dummy\n"


 def test_formatter_plugin(tmp_path, monkeypatch):
     monkeypatch.setitem(CODEFORMATTERS, "lang", example_formatter)
     file_path = tmp_path / "test_markdown.md"
     file_path.write_text("```lang\nother\n```\n")
     assert run((str(file_path),)) == 0
     assert file_path.read_text() == "```lang\ndummy\n```\n"


 def test_dash_stdin(capfd, patch_stdin):
     patch_stdin(UNFORMATTED_MARKDOWN)
     assert run(("-",)) == 0
     captured = capfd.readouterr()
     assert captured.out == FORMATTED_MARKDOWN


 def test_wrap_paragraphs():
     with patch("shutil.get_terminal_size", return_value=(72, 24)):
         assert wrap_paragraphs(
             [
                 'Error: Could not format "/home/user/file_name_longer_than_wrap_width--------------------------------------.md".',  # noqa: E501
                 "The formatted Markdown renders to different HTML than the input Markdown. "  # noqa: E501
                 "This is likely a bug in mdformat. "
                 "Please create an issue report here: "
                 "https://github.com/hukkin/mdformat/issues",
             ]
         ) == (
             "Error: Could not format\n"
             '"/home/user/file_name_longer_than_wrap_width--------------------------------------.md".\n'  # noqa: E501
             "\n"
             "The formatted Markdown renders to different HTML than the input\n"
             "Markdown. This is likely a bug in mdformat. Please create an issue\n"
             "report here: https://github.com/hukkin/mdformat/issues\n"
         )


 def test_version(capsys):
     with pytest.raises(SystemExit) as exc_info:
         run(["--version"])
     assert exc_info.value.code == 0
     captured = capsys.readouterr()
     assert captured.out.startswith(f"mdformat {mdformat.__version__}")


 def test_no_wrap(tmp_path):
     file_path = tmp_path / "test_markdown.md"
     file_path.write_text(
         "all\n"
         "these newlines\n"
         "except the one in this hardbreak  \n"
         "should be\n"
         "removed because they are\n"
         "in the same paragraph\n"
         "\n"
         "This however is the next\n"
         "paragraph.    Whitespace should  be collapsed\n"
         "    \t here\n"
     )
     assert run([str(file_path), "--wrap=no"]) == 0
     assert (
         file_path.read_text()
         == "all these newlines except the one in this hardbreak\\\n"
         "should be removed because they are in the same paragraph\n"
         "\n"
         "This however is the next paragraph. Whitespace should be collapsed here\n"
     )


 def test_wrap(tmp_path):
     file_path = tmp_path / "test_markdown.md"
     file_path.write_text(
         "This\n"
         "text\n"
         "should\n"
         "be wrapped again so that wrap width is whatever is defined below. "
         "Also     whitespace            should\t\tbe             collapsed. "
         "Next up a second paragraph:\n"
         "\n"
         "This paragraph should also be wrapped. "
         "Here's some more text to wrap.  "
         "Here's some more text to wrap.  "
         "Here's some more text to wrap.  "
     )
     assert run([str(file_path), "--wrap=60"]) == 0
     assert (
         file_path.read_text()
         == "This text should be wrapped again so that wrap width is\n"
         "whatever is defined below. Also whitespace should be\n"
         "collapsed. Next up a second paragraph:\n"
         "\n"
         "This paragraph should also be wrapped. Here's some more text\n"
         "to wrap. Here's some more text to wrap. Here's some more\n"
         "text to wrap.\n"
     )


 def test_consecutive_wrap_width_lines(tmp_path):
     """Test a case where two consecutive lines' width equals wrap width.

     There was a bug where this would cause an extra newline and split
     the paragraph, hence the test.
     """
     wrap_width = 20
     file_path = tmp_path / "test_markdown.md"
     text = "A" * wrap_width + "\n" + "A" * wrap_width + "\n"
     file_path.write_text(text)
     assert run([str(file_path), f"--wrap={wrap_width}"]) == 0
     assert file_path.read_text() == text


 def test_wrap__hard_break(tmp_path):
     file_path = tmp_path / "test_markdown.md"
     file_path.write_text(
         "This\n"
         "text\n"
         "should\n"
         "be wrapped again\\\n"
         "so that wrap width is whatever is defined below. "
         "Also     whitespace            should\t\tbe             collapsed."
     )
     assert run([str(file_path), "--wrap=60"]) == 0
     assert (
         file_path.read_text() == "This text should be wrapped again\\\n"
         "so that wrap width is whatever is defined below. Also\n"
         "whitespace should be collapsed.\n"
     )


 def test_bad_wrap_width(capsys):
     with pytest.raises(SystemExit) as exc_info:
         run(["some-path.md", "--wrap=-1"])
     assert exc_info.value.code == 2
     captured = capsys.readouterr()
     assert "error: argument --wrap" in captured.err


 def test_eol__lf(tmp_path):
     file_path = tmp_path / "test.md"
     file_path.write_bytes(b"Oi\r\n")
     assert run([str(file_path)]) == 0
     assert file_path.read_bytes() == b"Oi\n"


 def test_eol__crlf(tmp_path):
     file_path = tmp_path / "test.md"
     file_path.write_bytes(b"Oi\n")
     assert run([str(file_path), "--end-of-line=crlf"]) == 0
     assert file_path.read_bytes() == b"Oi\r\n"


 def test_eol__keep_lf(tmp_path):
     file_path = tmp_path / "test.md"
     file_path.write_bytes(b"Oi\n")
     assert run([str(file_path), "--end-of-line=keep"]) == 0
     assert file_path.read_bytes() == b"Oi\n"


 def test_eol__keep_crlf(tmp_path):
     file_path = tmp_path / "test.md"
     file_path.write_bytes(b"Oi\r\n")
     assert run([str(file_path), "--end-of-line=keep"]) == 0
     assert file_path.read_bytes() == b"Oi\r\n"


 def test_eol__crlf_stdin(capfd, patch_stdin):
     patch_stdin("Oi\n")
     assert run(["-", "--end-of-line=crlf"]) == 0
     captured = capfd.readouterr()
     assert captured.out == "Oi\r\n"


 def test_eol__check_lf(tmp_path):
     file_path = tmp_path / "test.md"

     file_path.write_bytes(b"lol\r\n")
     assert run((str(file_path), "--check")) == 1

     file_path.write_bytes(b"lol\n")
     assert run((str(file_path), "--check")) == 0


 def test_eol__check_crlf(tmp_path):
     file_path = tmp_path / "test.md"

     file_path.write_bytes(b"lol\n")
     assert run((str(file_path), "--check", "--end-of-line=crlf")) == 1

     file_path.write_bytes(b"lol\r\n")
     assert run((str(file_path), "--check", "--end-of-line=crlf")) == 0


 def test_eol__check_keep_lf(tmp_path):
     file_path = tmp_path / "test.md"

     file_path.write_bytes(b"lol\n")
     assert run((str(file_path), "--check", "--end-of-line=keep")) == 0

     file_path.write_bytes(b"mixed\nEOLs\r")
     assert run((str(file_path), "--check", "--end-of-line=keep")) == 1


 def test_eol__check_keep_crlf(tmp_path):
     file_path = tmp_path / "test.md"

     file_path.write_bytes(b"lol\r\n")
     assert run((str(file_path), "--check", "--end-of-line=keep")) == 0

     file_path.write_bytes(b"mixed\r\nEOLs\n")
     assert run((str(file_path), "--check", "--end-of-line=keep")) == 1


 def test_cli_no_validate(tmp_path):
     file_path = tmp_path / "test.md"
     content = "1. ordered"
     file_path.write_text(content)

     with patch("mdformat.renderer._context.get_list_marker_type", return_value="?"):
         assert run((str(file_path),)) == 1
         assert file_path.read_text() == content

         assert run((str(file_path), "--no-validate")) == 0
         assert file_path.read_text() == "1? ordered\n"


 def test_get_plugin_info_str():
     info = get_plugin_info_str(
         {"mdformat-tables": ("0.1.0", ["tables"])},
         {"mdformat-black": ("12.1.0", ["python"])},
     )
     assert (
         info
         == """\
 installed codeformatters:
   mdformat-black: python

 installed extensions:
   mdformat-tables: tables"""
     )


 def test_no_timestamp_modify(tmp_path):
     file_path = tmp_path / "test.md"

     file_path.write_bytes(b"lol\n")
     initial_access_time = 0
     initial_mod_time = 0
     os.utime(file_path, (initial_access_time, initial_mod_time))

     # Assert that modification time does not change when no changes are applied
     assert run([str(file_path)]) == 0
     assert os.path.getmtime(file_path) == initial_mod_time


 @pytest.mark.skipif(
     sys.version_info < (3, 13), reason="'exclude' only possible on 3.13+"
 )
 def test_exclude(tmp_path):
     subdir_path_1 = tmp_path / "folder1"
     subdir_path_2 = subdir_path_1 / "folder2"
     file_path_1 = subdir_path_2 / "file1.md"
     subdir_path_1.mkdir()
     subdir_path_2.mkdir()
     file_path_1.write_text(UNFORMATTED_MARKDOWN)
     cwd = tmp_path

     with patch("mdformat._cli.Path.cwd", return_value=cwd):
         for good_pattern in [
             "folder1/folder2/file1.md",
             "**",
             "**/*.md",
             "**/file1.md",
             "folder1/**",
         ]:
             assert run([str(file_path_1), "--exclude", good_pattern]) == 0
             assert file_path_1.read_text() == UNFORMATTED_MARKDOWN

         for bad_pattern in [
             "**file1.md",
             "file1.md",
             "folder1",
             "*.md",
             "*",
             "folder1/*",
         ]:
             file_path_1.write_text(UNFORMATTED_MARKDOWN)
             assert run([str(file_path_1), "--exclude", bad_pattern]) == 0
             assert file_path_1.read_text() == FORMATTED_MARKDOWN


 def test_codeformatters(tmp_path, monkeypatch):
     monkeypatch.setitem(CODEFORMATTERS, "enabled-lang", lambda code, info: "dumdum")
     monkeypatch.setitem(CODEFORMATTERS, "disabled-lang", lambda code, info: "dumdum")
     file_path = tmp_path / "test.md"
     unformatted = """\
 ```disabled-lang
 hey
 ```

 ```enabled-lang
 hey
 ```
 """
     formatted = """\
 ```disabled-lang
 hey
 ```

 ```enabled-lang
 dumdum
 ```
 """
     file_path.write_text(unformatted)
     assert run((str(file_path), "--codeformatters", "enabled-lang")) == 0
     assert file_path.read_text() == formatted


 def test_extensions(tmp_path, monkeypatch):
     ast_plugin_name = "ast-plug"
     prefix_plugin_name = "prefix-plug"
     monkeypatch.setitem(PARSER_EXTENSIONS, ast_plugin_name, ASTChangingPlugin)
     monkeypatch.setitem(PARSER_EXTENSIONS, prefix_plugin_name, PrefixPostprocessPlugin)
     unformatted = "original text\n"
     file_path = tmp_path / "test.md"

     file_path.write_text(unformatted)
     assert run((str(file_path), "--extensions", "prefix-plug")) == 0
     assert file_path.read_text() == "Prefixed!original text\n"

     file_path.write_text(unformatted)
     assert run((str(file_path), "--extensions", "ast-plug")) == 0
     assert file_path.read_text() == ASTChangingPlugin.TEXT_REPLACEMENT + "\n"

     file_path.write_text(unformatted)
     assert (
         run((str(file_path), "--extensions", "ast-plug", "--extensions", "prefix-plug"))
         == 0
     )
     assert (
         file_path.read_text() == "Prefixed!" + ASTChangingPlugin.TEXT_REPLACEMENT + "\n"
     )


 def test_codeformatters__invalid(tmp_path, capsys):
     file_path = tmp_path / "test.md"
     file_path.write_text("")
     assert run((str(file_path), "--codeformatters", "no-exists")) == 1
     captured = capsys.readouterr()
     assert "Error: Invalid code formatter required" in captured.err


 def test_extensions__invalid(tmp_path, capsys):
     file_path = tmp_path / "test.md"
     file_path.write_text("")
     assert run((str(file_path), "--extensions", "no-exists")) == 1
     captured = capsys.readouterr()
     assert "Error: Invalid extension required" in captured.err


 def test_no_codeformatters(tmp_path, monkeypatch):
     monkeypatch.setitem(CODEFORMATTERS, "lang", lambda code, info: "dumdum")
     file_path = tmp_path / "test.md"
     original_md = """\
 ```lang
 original code
 ```
 """
     file_path.write_text(original_md)
     assert run((str(file_path), "--no-codeformatters")) == 0
     assert file_path.read_text() == original_md


 def test_no_extensions(tmp_path, monkeypatch):
     plugin_name = "plug-name"
     monkeypatch.setitem(PARSER_EXTENSIONS, plugin_name, ASTChangingPlugin)
     file_path = tmp_path / "test.md"
     original_md = "original md\n"
     file_path.write_text(original_md)
     assert run((str(file_path), "--no-extensions")) == 0
     assert file_path.read_text() == original_md
	import os
	import sys
	from unittest.mock import patch

	import pytest

	import mdformat
	from mdformat._cli import get_plugin_info_str, run, wrap_paragraphs
	from mdformat.plugins import CODEFORMATTERS, PARSER_EXTENSIONS
	from tests.utils import (
	FORMATTED_MARKDOWN,
	UNFORMATTED_MARKDOWN,
	ASTChangingPlugin,
	PrefixPostprocessPlugin,
	)


	def test_no_files_passed():
	assert run(()) == 0


	def test_format(tmp_path):
	file_path = tmp_path / "test_markdown.md"
	file_path.write_text(UNFORMATTED_MARKDOWN)
	assert run((str(file_path),)) == 0
	assert file_path.read_text() == FORMATTED_MARKDOWN


	def test_format__folder(tmp_path):
	file_path_1 = tmp_path / "test_markdown1.md"
	file_path_2 = tmp_path / "test_markdown2.md"
	file_path_3 = tmp_path / "not_markdown3"
	file_path_1.write_text(UNFORMATTED_MARKDOWN)
	file_path_2.write_text(UNFORMATTED_MARKDOWN)
	file_path_3.write_text(UNFORMATTED_MARKDOWN)
	assert run((str(tmp_path),)) == 0
	assert file_path_1.read_text() == FORMATTED_MARKDOWN
	assert file_path_2.read_text() == FORMATTED_MARKDOWN
	assert file_path_3.read_text() == UNFORMATTED_MARKDOWN


	def test_format__folder_leads_to_invalid(tmp_path):
	file_path_1 = tmp_path / "test_markdown1.md"
	file_path_1.mkdir()
	assert run((str(tmp_path),)) == 0
	assert file_path_1.is_dir()


	def test_format__symlinks(tmp_path):
	# Create two MD files
	file_path_1 = tmp_path / "test_markdown1.md"
	file_path_2 = tmp_path / "test_markdown2.md"
	file_path_1.write_text(UNFORMATTED_MARKDOWN)
	file_path_2.write_text(UNFORMATTED_MARKDOWN)

	# Create a symlink to both files: one in the root folder, one in a sub folder
	subdir_path = tmp_path / "subdir"
	subdir_path.mkdir()
	symlink_1 = subdir_path / "symlink1.md"
	symlink_1.symlink_to(file_path_1)
	symlink_2 = tmp_path / "symlink2.md"
	symlink_2.symlink_to(file_path_2)

	# Format file 1 via directory of the symlink, and file 2 via symlink
	assert run([str(subdir_path), str(symlink_2)]) == 0

	# Assert that files are formatted and symlinks are not overwritten
	assert file_path_1.read_text() == FORMATTED_MARKDOWN
	assert file_path_2.read_text() == FORMATTED_MARKDOWN
	assert symlink_1.is_symlink()
	assert symlink_2.is_symlink()


	def test_broken_symlink(tmp_path, capsys):
	# Create a broken symlink
	file_path = tmp_path / "test_markdown1.md"
	symlink_path = tmp_path / "symlink"
	symlink_path.symlink_to(file_path)

	with pytest.raises(SystemExit) as exc_info:
	run([str(symlink_path)])
	assert exc_info.value.code == 2
	captured = capsys.readouterr()
	assert "does not exist" in captured.err


	def test_invalid_file(capsys):
	with pytest.raises(SystemExit) as exc_info:
	run(("this is not a valid filepath?`=\|><@{[]\\/,.%¤#'",))
	assert exc_info.value.code == 2
	captured = capsys.readouterr()
	assert "does not exist" in captured.err


	@pytest.mark.skipif(os.name == "nt", reason="No os.mkfifo on windows")
	def test_fifo(tmp_path, capsys):
	fifo_path = tmp_path / "fifo1"
	os.mkfifo(fifo_path)
	with pytest.raises(SystemExit) as exc_info:
	run((str(fifo_path),))
	assert exc_info.value.code == 2
	assert "does not exist" in capsys.readouterr().err


	def test_check(tmp_path):
	file_path = tmp_path / "test_markdown.md"
	file_path.write_bytes(FORMATTED_MARKDOWN.encode())
	assert run((str(file_path), "--check")) == 0


	def test_check__fail(tmp_path):
	file_path = tmp_path / "test_markdown.md"
	file_path.write_text(UNFORMATTED_MARKDOWN)
	assert run((str(file_path), "--check")) == 1


	def test_check__multi_fail(capsys, tmp_path):
	"""Test for --check flag when multiple files are unformatted.

	Test that the names of all unformatted files are listed when using
	--check.
	"""
	file_path1 = tmp_path / "test_markdown1.md"
	file_path2 = tmp_path / "test_markdown2.md"
	file_path1.write_text(UNFORMATTED_MARKDOWN)
	file_path2.write_text(UNFORMATTED_MARKDOWN)
	assert run((str(tmp_path), "--check")) == 1
	captured = capsys.readouterr()
	assert str(file_path1) in captured.err
	assert str(file_path2) in captured.err


	def example_formatter(code, info):
	return "dummy\n"


	def test_formatter_plugin(tmp_path, monkeypatch):
	monkeypatch.setitem(CODEFORMATTERS, "lang", example_formatter)
	file_path = tmp_path / "test_markdown.md"
	file_path.write_text("```lang\nother\n```\n")
	assert run((str(file_path),)) == 0
	assert file_path.read_text() == "```lang\ndummy\n```\n"


	def test_dash_stdin(capfd, patch_stdin):
	patch_stdin(UNFORMATTED_MARKDOWN)
	assert run(("-",)) == 0
	captured = capfd.readouterr()
	assert captured.out == FORMATTED_MARKDOWN


	def test_wrap_paragraphs():
	with patch("shutil.get_terminal_size", return_value=(72, 24)):
	assert wrap_paragraphs(
	[
	'Error: Could not format "/home/user/file_name_longer_than_wrap_width--------------------------------------.md".', # noqa: E501
	"The formatted Markdown renders to different HTML than the input Markdown. " # noqa: E501
	"This is likely a bug in mdformat. "
	"Please create an issue report here: "
	"https://github.com/hukkin/mdformat/issues",
	]
	) == (
	"Error: Could not format\n"
	'"/home/user/file_name_longer_than_wrap_width--------------------------------------.md".\n' # noqa: E501
	"\n"
	"The formatted Markdown renders to different HTML than the input\n"
	"Markdown. This is likely a bug in mdformat. Please create an issue\n"
	"report here: https://github.com/hukkin/mdformat/issues\n"
	)


	def test_version(capsys):
	with pytest.raises(SystemExit) as exc_info:
	run(["--version"])
	assert exc_info.value.code == 0
	captured = capsys.readouterr()
	assert captured.out.startswith(f"mdformat {mdformat.__version__}")


	def test_no_wrap(tmp_path):
	file_path = tmp_path / "test_markdown.md"
	file_path.write_text(
	"all\n"
	"these newlines\n"
	"except the one in this hardbreak \n"
	"should be\n"
	"removed because they are\n"
	"in the same paragraph\n"
	"\n"
	"This however is the next\n"
	"paragraph. Whitespace should be collapsed\n"
	" \t here\n"
	)
	assert run([str(file_path), "--wrap=no"]) == 0
	assert (
	file_path.read_text()
	== "all these newlines except the one in this hardbreak\\\n"
	"should be removed because they are in the same paragraph\n"
	"\n"
	"This however is the next paragraph. Whitespace should be collapsed here\n"
	)


	def test_wrap(tmp_path):
	file_path = tmp_path / "test_markdown.md"
	file_path.write_text(
	"This\n"
	"text\n"
	"should\n"
	"be wrapped again so that wrap width is whatever is defined below. "
	"Also whitespace should\t\tbe collapsed. "
	"Next up a second paragraph:\n"
	"\n"
	"This paragraph should also be wrapped. "
	"Here's some more text to wrap. "
	"Here's some more text to wrap. "
	"Here's some more text to wrap. "
	)
	assert run([str(file_path), "--wrap=60"]) == 0
	assert (
	file_path.read_text()
	== "This text should be wrapped again so that wrap width is\n"
	"whatever is defined below. Also whitespace should be\n"
	"collapsed. Next up a second paragraph:\n"
	"\n"
	"This paragraph should also be wrapped. Here's some more text\n"
	"to wrap. Here's some more text to wrap. Here's some more\n"
	"text to wrap.\n"
	)


	def test_consecutive_wrap_width_lines(tmp_path):
	"""Test a case where two consecutive lines' width equals wrap width.

	There was a bug where this would cause an extra newline and split
	the paragraph, hence the test.
	"""
	wrap_width = 20
	file_path = tmp_path / "test_markdown.md"
	text = "A" * wrap_width + "\n" + "A" * wrap_width + "\n"
	file_path.write_text(text)
	assert run([str(file_path), f"--wrap={wrap_width}"]) == 0
	assert file_path.read_text() == text


	def test_wrap__hard_break(tmp_path):
	file_path = tmp_path / "test_markdown.md"
	file_path.write_text(
	"This\n"
	"text\n"
	"should\n"
	"be wrapped again\\\n"
	"so that wrap width is whatever is defined below. "
	"Also whitespace should\t\tbe collapsed."
	)
	assert run([str(file_path), "--wrap=60"]) == 0
	assert (
	file_path.read_text() == "This text should be wrapped again\\\n"
	"so that wrap width is whatever is defined below. Also\n"
	"whitespace should be collapsed.\n"
	)


	def test_bad_wrap_width(capsys):
	with pytest.raises(SystemExit) as exc_info:
	run(["some-path.md", "--wrap=-1"])
	assert exc_info.value.code == 2
	captured = capsys.readouterr()
	assert "error: argument --wrap" in captured.err


	def test_eol__lf(tmp_path):
	file_path = tmp_path / "test.md"
	file_path.write_bytes(b"Oi\r\n")
	assert run([str(file_path)]) == 0
	assert file_path.read_bytes() == b"Oi\n"


	def test_eol__crlf(tmp_path):
	file_path = tmp_path / "test.md"
	file_path.write_bytes(b"Oi\n")
	assert run([str(file_path), "--end-of-line=crlf"]) == 0
	assert file_path.read_bytes() == b"Oi\r\n"


	def test_eol__keep_lf(tmp_path):
	file_path = tmp_path / "test.md"
	file_path.write_bytes(b"Oi\n")
	assert run([str(file_path), "--end-of-line=keep"]) == 0
	assert file_path.read_bytes() == b"Oi\n"


	def test_eol__keep_crlf(tmp_path):
	file_path = tmp_path / "test.md"
	file_path.write_bytes(b"Oi\r\n")
	assert run([str(file_path), "--end-of-line=keep"]) == 0
	assert file_path.read_bytes() == b"Oi\r\n"


	def test_eol__crlf_stdin(capfd, patch_stdin):
	patch_stdin("Oi\n")
	assert run(["-", "--end-of-line=crlf"]) == 0
	captured = capfd.readouterr()
	assert captured.out == "Oi\r\n"


	def test_eol__check_lf(tmp_path):
	file_path = tmp_path / "test.md"

	file_path.write_bytes(b"lol\r\n")
	assert run((str(file_path), "--check")) == 1

	file_path.write_bytes(b"lol\n")
	assert run((str(file_path), "--check")) == 0


	def test_eol__check_crlf(tmp_path):
	file_path = tmp_path / "test.md"

	file_path.write_bytes(b"lol\n")
	assert run((str(file_path), "--check", "--end-of-line=crlf")) == 1

	file_path.write_bytes(b"lol\r\n")
	assert run((str(file_path), "--check", "--end-of-line=crlf")) == 0


	def test_eol__check_keep_lf(tmp_path):
	file_path = tmp_path / "test.md"

	file_path.write_bytes(b"lol\n")
	assert run((str(file_path), "--check", "--end-of-line=keep")) == 0

	file_path.write_bytes(b"mixed\nEOLs\r")
	assert run((str(file_path), "--check", "--end-of-line=keep")) == 1


	def test_eol__check_keep_crlf(tmp_path):
	file_path = tmp_path / "test.md"

	file_path.write_bytes(b"lol\r\n")
	assert run((str(file_path), "--check", "--end-of-line=keep")) == 0

	file_path.write_bytes(b"mixed\r\nEOLs\n")
	assert run((str(file_path), "--check", "--end-of-line=keep")) == 1


	def test_cli_no_validate(tmp_path):
	file_path = tmp_path / "test.md"
	content = "1. ordered"
	file_path.write_text(content)

	with patch("mdformat.renderer._context.get_list_marker_type", return_value="?"):
	assert run((str(file_path),)) == 1
	assert file_path.read_text() == content

	assert run((str(file_path), "--no-validate")) == 0
	assert file_path.read_text() == "1? ordered\n"


	def test_get_plugin_info_str():
	info = get_plugin_info_str(
	{"mdformat-tables": ("0.1.0", ["tables"])},
	{"mdformat-black": ("12.1.0", ["python"])},
	)
	assert (
	info
	== """\
	installed codeformatters:
	mdformat-black: python

	installed extensions:
	mdformat-tables: tables"""
	)


	def test_no_timestamp_modify(tmp_path):
	file_path = tmp_path / "test.md"

	file_path.write_bytes(b"lol\n")
	initial_access_time = 0
	initial_mod_time = 0
	os.utime(file_path, (initial_access_time, initial_mod_time))

	# Assert that modification time does not change when no changes are applied
	assert run([str(file_path)]) == 0
	assert os.path.getmtime(file_path) == initial_mod_time


	@pytest.mark.skipif(
	sys.version_info < (3, 13), reason="'exclude' only possible on 3.13+"
	)
	def test_exclude(tmp_path):
	subdir_path_1 = tmp_path / "folder1"
	subdir_path_2 = subdir_path_1 / "folder2"
	file_path_1 = subdir_path_2 / "file1.md"
	subdir_path_1.mkdir()
	subdir_path_2.mkdir()
	file_path_1.write_text(UNFORMATTED_MARKDOWN)
	cwd = tmp_path

	with patch("mdformat._cli.Path.cwd", return_value=cwd):
	for good_pattern in [
	"folder1/folder2/file1.md",
	"**",
	"*/.md",
	"**/file1.md",
	"folder1/**",
	]:
	assert run([str(file_path_1), "--exclude", good_pattern]) == 0
	assert file_path_1.read_text() == UNFORMATTED_MARKDOWN

	for bad_pattern in [
	"**file1.md",
	"file1.md",
	"folder1",
	"*.md",
	"*",
	"folder1/*",
	]:
	file_path_1.write_text(UNFORMATTED_MARKDOWN)
	assert run([str(file_path_1), "--exclude", bad_pattern]) == 0
	assert file_path_1.read_text() == FORMATTED_MARKDOWN


	def test_codeformatters(tmp_path, monkeypatch):
	monkeypatch.setitem(CODEFORMATTERS, "enabled-lang", lambda code, info: "dumdum")
	monkeypatch.setitem(CODEFORMATTERS, "disabled-lang", lambda code, info: "dumdum")
	file_path = tmp_path / "test.md"
	unformatted = """\
	```disabled-lang
	hey
	```

	```enabled-lang
	hey
	```
	"""
	formatted = """\
	```disabled-lang
	hey
	```

	```enabled-lang
	dumdum
	```
	"""
	file_path.write_text(unformatted)
	assert run((str(file_path), "--codeformatters", "enabled-lang")) == 0
	assert file_path.read_text() == formatted


	def test_extensions(tmp_path, monkeypatch):
	ast_plugin_name = "ast-plug"
	prefix_plugin_name = "prefix-plug"
	monkeypatch.setitem(PARSER_EXTENSIONS, ast_plugin_name, ASTChangingPlugin)
	monkeypatch.setitem(PARSER_EXTENSIONS, prefix_plugin_name, PrefixPostprocessPlugin)
	unformatted = "original text\n"
	file_path = tmp_path / "test.md"

	file_path.write_text(unformatted)
	assert run((str(file_path), "--extensions", "prefix-plug")) == 0
	assert file_path.read_text() == "Prefixed!original text\n"

	file_path.write_text(unformatted)
	assert run((str(file_path), "--extensions", "ast-plug")) == 0
	assert file_path.read_text() == ASTChangingPlugin.TEXT_REPLACEMENT + "\n"

	file_path.write_text(unformatted)
	assert (
	run((str(file_path), "--extensions", "ast-plug", "--extensions", "prefix-plug"))
	== 0
	)
	assert (
	file_path.read_text() == "Prefixed!" + ASTChangingPlugin.TEXT_REPLACEMENT + "\n"
	)


	def test_codeformatters__invalid(tmp_path, capsys):
	file_path = tmp_path / "test.md"
	file_path.write_text("")
	assert run((str(file_path), "--codeformatters", "no-exists")) == 1
	captured = capsys.readouterr()
	assert "Error: Invalid code formatter required" in captured.err


	def test_extensions__invalid(tmp_path, capsys):
	file_path = tmp_path / "test.md"
	file_path.write_text("")
	assert run((str(file_path), "--extensions", "no-exists")) == 1
	captured = capsys.readouterr()
	assert "Error: Invalid extension required" in captured.err


	def test_no_codeformatters(tmp_path, monkeypatch):
	monkeypatch.setitem(CODEFORMATTERS, "lang", lambda code, info: "dumdum")
	file_path = tmp_path / "test.md"
	original_md = """\
	```lang
	original code
	```
	"""
	file_path.write_text(original_md)
	assert run((str(file_path), "--no-codeformatters")) == 0
	assert file_path.read_text() == original_md


	def test_no_extensions(tmp_path, monkeypatch):
	plugin_name = "plug-name"
	monkeypatch.setitem(PARSER_EXTENSIONS, plugin_name, ASTChangingPlugin)
	file_path = tmp_path / "test.md"
	original_md = "original md\n"
	file_path.write_text(original_md)
	assert run((str(file_path), "--no-extensions")) == 0
	assert file_path.read_text() == original_md