refactor(commit): refactor test case and logic for tag --body-length-limit in commit command

Author: yjaw

commitizen/commands/commit.py

@@ -7,6 +7,7 @@
 import tempfile
 from pathlib import Path
 import textwrap
+from itertools import chain
 from typing import TYPE_CHECKING, TypedDict
 
 import questionary
@@ -84,7 +85,7 @@ def _get_message_by_prompt_commit_questions(self) -> str:
 
         message = self.cz.message(answers)
         self._validate_subject_length(message)
-        message = self._rewrap_body(message)
+        message = self._wrap_body(message)
         return message
 
     def _validate_subject_length(self, message: str) -> None:
@@ -103,30 +104,23 @@ def _validate_subject_length(self, message: str) -> None:
                 f"Length of commit message exceeds limit ({len(subject)}/{message_length_limit}), subject: '{subject}'"
             )
 
-    def _rewrap_body(self, message: str) -> str:
+    def _wrap_body(self, message: str) -> str:
         body_length_limit = self.arguments.get(
             "body_length_limit", self.config.settings.get("body_length_limit", 0)
         )
         # By the contract, body_length_limit is set to 0 for no limit
-        if (
-            body_length_limit is None or body_length_limit <= 0
-        ):  # do nothing for no limit
+        if body_length_limit <= 0:
             return message
 
-        message_parts = message.split("\n", 2)
-        if len(message_parts) < 3:
+        lines = message.split("\n")
+        if len(lines) < 3:
             return message
 
         # First line is subject, second is blank line, rest is body
-        subject = message_parts[0]
-        blank_line = message_parts[1]
-        body = message_parts[2].strip()
-        body_lines = body.split("\n")
-        wrapped_body_lines = []
-        for line in body_lines:
-            wrapped_body_lines.append(textwrap.fill(line, width=body_length_limit))
-        wrapped_body = "\n".join(wrapped_body_lines)
-        return f"{subject}\n{blank_line}\n{wrapped_body}"
+        wrapped_body_lines = [
+            textwrap.wrap(line, width=body_length_limit) for line in lines[2:]
+        ]
+        return "\n".join(chain(lines[:2], chain.from_iterable(wrapped_body_lines)))
 
     def manual_edit(self, message: str) -> str:
         editor = git.get_core_editor()

tests/commands/test_commit_command.py

@@ -377,227 +377,76 @@ def test_commit_command_with_config_message_length_limit(
 
 
 @pytest.mark.usefixtures("staging_is_clean")
-def test_commit_command_with_body_length_limit_wrapping(
-    config, success_mock: MockType, mocker: MockFixture
-):
-    """Test that long body lines are automatically wrapped to the specified limit."""
-    mocker.patch(
-        "questionary.prompt",
-        return_value={
-            "prefix": "feat",
-            "subject": "add feature",
-            "scope": "",
-            "is_breaking_change": False,
-            "body": "This is a very long line that exceeds 72 characters and should be automatically wrapped by the system to fit within the limit",
-            "footer": "",
-        },
-    )
-
-    commit_mock = mocker.patch(
-        "commitizen.git.commit", return_value=cmd.Command("success", "", b"", b"", 0)
-    )
-
-    # Execute with body_length_limit
-    commands.Commit(config, {"body_length_limit": 72})()
-    success_mock.assert_called_once()
-
-    # Verify wrapping occurred
-    committed_message = commit_mock.call_args[0][0]
-    lines = committed_message.split("\n")
-    assert lines[0] == "feat: add feature"
-    assert lines[1] == ""
-    body_lines = lines[2:]
-    for line in body_lines:
-        if line.strip():
-            assert len(line) <= 72, (
-                f"Line exceeds 72 chars: '{line}' ({len(line)} chars)"
-            )
-
-
-@pytest.mark.usefixtures("staging_is_clean")
-def test_commit_command_with_body_length_limit_preserves_line_breaks(
-    config, success_mock: MockType, mocker: MockFixture
-):
-    """Test that intentional line breaks (from | character) are preserved."""
-    # Simulate what happens after multiple_line_breaker processes "line1 | line2 | line3"
-    mocker.patch(
-        "questionary.prompt",
-        return_value={
-            "prefix": "feat",
-            "subject": "add feature",
-            "scope": "",
-            "is_breaking_change": False,
-            "body": "Line1 that is very long and exceeds the limit\nLine2 that is very long and exceeds the limit\nLine3 that is very long and exceeds the limit",
-            "footer": "",
-        },
-    )
-
-    commit_mock = mocker.patch(
-        "commitizen.git.commit", return_value=cmd.Command("success", "", b"", b"", 0)
-    )
-
-    commands.Commit(config, {"body_length_limit": 45})()
-    success_mock.assert_called_once()
-
-    committed_message = commit_mock.call_args[0][0]
-    lines = committed_message.split("\n")
-
-    # Should have a subject, a blank line
-    assert lines[0] == "feat: add feature"
-    assert lines[1] == ""
-    # Each original line should be wrapped separately, preserving the line breaks
-    body_lines = lines[2:]
-    # All lines should be <= 45 chars
-    for line in body_lines:
-        if line.strip():
-            assert len(line) == 45, (
-                f"Line's length is not 45 chars: '{line}' ({len(line)} chars)"
-            )
-
-
-@pytest.mark.usefixtures("staging_is_clean")
-def test_commit_command_with_body_length_limit_disabled(
-    config, success_mock: MockType, mocker: MockFixture
-):
-    """Test that body_length_limit = 0 disables wrapping."""
-    long_body = "This is a very long line that exceeds 72 characters and should NOT be wrapped when body_length_limit is set to 0"
-
-    mocker.patch(
-        "questionary.prompt",
-        return_value={
-            "prefix": "feat",
-            "subject": "add feature",
-            "scope": "",
-            "is_breaking_change": False,
-            "body": long_body,
-            "footer": "",
-        },
-    )
-
-    commit_mock = mocker.patch(
-        "commitizen.git.commit", return_value=cmd.Command("success", "", b"", b"", 0)
-    )
-
-    # Execute with body_length_limit = 0 (disabled)
-    commands.Commit(config, {"body_length_limit": 0})()
-
-    success_mock.assert_called_once()
-
-    # Get the actual commit message
-    committed_message = commit_mock.call_args[0][0]
-
-    # Verify the body was NOT wrapped (should contain the original long line)
-    assert long_body in committed_message, "Body should not be wrapped when limit is 0"
-
-
-@pytest.mark.usefixtures("staging_is_clean")
-def test_commit_command_with_body_length_limit_from_config(
-    config, success_mock: MockType, mocker: MockFixture
+@pytest.mark.parametrize(
+    "test_id,body,body_length_limit",
+    [
+        # Basic wrapping - long line gets wrapped
+        (
+            "wrapping",
+            "This is a very long line that exceeds 72 characters and should be automatically wrapped by the system to fit within the limit",
+            72,
+        ),
+        # Line break preservation - multiple lines with \n
+        (
+            "preserves_line_breaks",
+            "Line1 that is very long and exceeds the limit\nLine2 that is very long and exceeds the limit\nLine3 that is very long and exceeds the limit",
+            72,
+        ),
+        # Disabled wrapping - limit = 0
+        (
+            "disabled",
+            "This is a very long line that exceeds 72 characters and should NOT be wrapped when body_length_limit is set to 0",
+            0,
+        ),
+        # No body - empty string
+        (
+            "no_body",
+            "",
+            72,
+        ),
+    ],
+)
+def test_commit_command_body_length_limit(
+    test_id,
+    body,
+    body_length_limit,
+    config,
+    success_mock: MockType,
+    commit_mock,
+    mocker: MockFixture,
+    file_regression,
 ):
-    """Test that body_length_limit can be set via config."""
+    """Parameterized test for body_length_limit feature with file regression."""
     mocker.patch(
         "questionary.prompt",
         return_value={
             "prefix": "feat",
             "subject": "add feature",
             "scope": "",
             "is_breaking_change": False,
-            "body": "This is a very long line that exceeds 50 characters and should be wrapped",
+            "body": body,
             "footer": "",
         },
     )
 
-    commit_mock = mocker.patch(
-        "commitizen.git.commit", return_value=cmd.Command("success", "", b"", b"", 0)
-    )
-
-    # Set body_length_limit in config
-    config.settings["body_length_limit"] = 50
-
+    config.settings["body_length_limit"] = body_length_limit
     commands.Commit(config, {})()
 
     success_mock.assert_called_once()
-
-    # Get the actual commit message
     committed_message = commit_mock.call_args[0][0]
 
-    # Verify all body lines are within the limit
-    lines = committed_message.split("\n")
-    body_lines = lines[2:]
-    for line in body_lines:
-        if line.strip():
-            assert len(line) <= 50, (
-                f"Line exceeds 50 chars: '{line}' ({len(line)} chars)"
-            )
-
-
-@pytest.mark.usefixtures("staging_is_clean")
-def test_commit_command_body_length_limit_cli_overrides_config(
-    config, success_mock: MockType, mocker: MockFixture
-):
-    """Test that CLI argument overrides config setting."""
-    mocker.patch(
-        "questionary.prompt",
-        return_value={
-            "prefix": "feat",
-            "subject": "add feature",
-            "scope": "",
-            "is_breaking_change": False,
-            "body": "This is a line that is longer than 40 characters but shorter than 80 characters",
-            "footer": "",
-        },
+    # File regression check - uses test_id to create separate files
+    file_regression.check(
+        committed_message,
+        extension=".txt",
+        basename=f"test_commit_command_body_length_limit_{test_id}",
     )
 
-    commit_mock = mocker.patch(
-        "commitizen.git.commit", return_value=cmd.Command("success", "", b"", b"", 0)
-    )
-
-    # Set config to 40 (would wrap)
-    config.settings["body_length_limit"] = 40
-
-    # Override with CLI argument to 0 (should NOT wrap)
-    commands.Commit(config, {"body_length_limit": 0})()
-
-    success_mock.assert_called_once()
-
-    # Get the actual commit message
-    committed_message = commit_mock.call_args[0][0]
-
-    # The line should NOT be wrapped (CLI override to 0 disables wrapping)
-    assert (
-        "This is a line that is longer than 40 characters but shorter than 80 characters"
-        in committed_message
-    )
-
-
-@pytest.mark.usefixtures("staging_is_clean")
-def test_commit_command_with_body_length_limit_no_body(
-    config, success_mock: MockType, mocker: MockFixture
-):
-    """Test that commits without body work correctly with body_length_limit set."""
-    mocker.patch(
-        "questionary.prompt",
-        return_value={
-            "prefix": "feat",
-            "subject": "add feature",
-            "scope": "",
-            "is_breaking_change": False,
-            "body": "",  # No body
-            "footer": "",
-        },
-    )
-
-    commit_mock = mocker.patch(
-        "commitizen.git.commit", return_value=cmd.Command("success", "", b"", b"", 0)
-    )
-
-    # Execute commit with body_length_limit (should not crash)
-    commands.Commit(config, {"body_length_limit": 72})()
-
-    success_mock.assert_called_once()
-
-    # Get the actual commit message
-    committed_message = commit_mock.call_args[0][0]
-
-    # Should just be the subject line
-    assert committed_message.strip() == "feat: add feature"
+    # Validate line lengths if limit is not 0
+    if body_length_limit > 0:
+        lines = committed_message.split("\n")
+        body_lines = lines[2:]  # Skip subject and blank line
+        for line in body_lines:
+            assert len(line) <= body_length_limit, (
+                f"Line exceeds {body_length_limit} chars: '{line}' ({len(line)} chars)"
+            )

tests/commands/test_commit_command/test_commit_command_body_length_limit_disabled.txt

@@ -0,0 +1,3 @@
+feat: add feature
+
+This is a very long line that exceeds 72 characters and should NOT be wrapped when body_length_limit is set to 0

tests/commands/test_commit_command/test_commit_command_body_length_limit_no_body.txt

@@ -0,0 +1 @@
+feat: add feature

tests/commands/test_commit_command/test_commit_command_body_length_limit_preserves_line_breaks.txt

@@ -0,0 +1,5 @@
+feat: add feature
+
+Line1 that is very long and exceeds the limit
+Line2 that is very long and exceeds the limit
+Line3 that is very long and exceeds the limit

tests/commands/test_commit_command/test_commit_command_body_length_limit_wrapping.txt

@@ -0,0 +1,4 @@
+feat: add feature
+
+This is a very long line that exceeds 72 characters and should be
+automatically wrapped by the system to fit within the limit