Setup unit tests for public methods

Author: woojiahao

pyproject.toml

@@ -21,3 +21,7 @@ license.file = "LICENSE"
 Homepage = "https://github.com/git-mastery/difflib-parser.git"
 Repository = "https://github.com/git-mastery/difflib-parser.git"
 Issues = "https://github.com/git-mastery/difflib-parser/issues"
+
+[tool.pytest.ini_options]
+addopts = ["--import-mode=importlib"]
+pythonpath = ["src"]

requirements.txt

@@ -0,0 +1 @@
+pytest

src/difflib_parser/diff_line.py

@@ -0,0 +1,40 @@
+from enum import Enum
+
+
+class DiffLineCode(Enum):
+    ADDED = 0
+    REMOVED = 1
+    COMMON = 2
+    MISSING = 3
+
+
+class DiffLine:
+    def __init__(self, line: str | None):
+        self.__line = line
+        print(self.__line)
+
+    @staticmethod
+    def parse(line: str | None) -> "DiffLine":
+        return DiffLine(line)
+
+    @property
+    def code(self) -> DiffLineCode | None:
+        if self.__line is None:
+            return None
+
+        match self.__line[:2]:
+            case "+ ":
+                return DiffLineCode.ADDED
+            case "- ":
+                return DiffLineCode.REMOVED
+            case "  ":
+                return DiffLineCode.COMMON
+            case "? ":
+                return DiffLineCode.MISSING
+
+    @property
+    def line(self) -> str | None:
+        if self.__line is None:
+            return None
+
+        return self.__line[2:]

src/difflib_parser/difflib_parser.py

@@ -3,6 +3,8 @@
 from enum import Enum
 from dataclasses import dataclass
 
+from difflib_parser.diff_line import DiffLine, DiffLineCode
+
 
 class DiffCode(Enum):
     SAME = 0
@@ -11,44 +13,6 @@ class DiffCode(Enum):
     CHANGED = 3
 
 
-class DiffLineCode(Enum):
-    ADDED = 0
-    REMOVED = 1
-    COMMON = 2
-    MISSING = 3
-
-
-class DiffLine:
-    def __init__(self, line: str | None):
-        self.__line = line
-
-    @staticmethod
-    def parse(line: str) -> "DiffLine":
-        return DiffLine(line)
-
-    @property
-    def code(self) -> DiffLineCode | None:
-        if self.__line is None:
-            return None
-
-        match self.__line[:2]:
-            case "+ ":
-                return DiffLineCode.ADDED
-            case "- ":
-                return DiffLineCode.REMOVED
-            case "  ":
-                return DiffLineCode.COMMON
-            case "? ":
-                return DiffLineCode.MISSING
-
-    @property
-    def line(self) -> str | None:
-        if self.__line is None:
-            return None
-
-        return self.__line[2:]
-
-
 @dataclass
 class DiffChange:
     left: List[int]
@@ -68,7 +32,7 @@ class Diff:
 
 # Parser inspired by https://github.com/yebrahim/difflibparser/blob/master/difflibparser.py
 class DiffParser:
-    def __init__(self, left_text, right_text):
+    def __init__(self, left_text: List[str], right_text: List[str]):
         self.__left_text = left_text
         self.__right_text = right_text
         self.__diff = list(difflib.ndiff(self.__left_text, self.__right_text))
@@ -80,6 +44,7 @@ def iter_diffs(self) -> Generator[Diff, Any, Any]:
             diff_line = DiffLine.parse(current_line)
             code = diff_line.code
             diff = Diff(code=DiffCode.SAME, line=diff_line.line)
+
             if code == DiffLineCode.ADDED:
                 diff.code = DiffCode.RIGHT_ONLY
             elif code == DiffLineCode.REMOVED:
@@ -92,6 +57,7 @@ def iter_diffs(self) -> Generator[Diff, Any, Any]:
                     diff.right_changes = change.right
                     diff.newline = change.newline
                     self.__line_no = change.skip_lines
+
             self.__line_no += 1
             yield diff
 
@@ -103,6 +69,9 @@ def __get_incremental_change(self, line_no: int) -> DiffChange | None:
             for i in range(4)
         ]
 
+        [_, b, c, d] = lines
+
+        # This represents the case where both additions and removals are present in the edit
         pattern_a = [
             DiffLineCode.REMOVED,
             DiffLineCode.MISSING,
@@ -111,27 +80,29 @@ def __get_incremental_change(self, line_no: int) -> DiffChange | None:
         ]
         if self.__match_pattern(lines, pattern_a):
             return DiffChange(
-                left=[i for (i, c) in enumerate(lines[1].line) if c in ["-", "^"]],
-                right=[i for (i, c) in enumerate(lines[3].line) if c in ["+", "^"]],
-                newline=lines[2].line,
+                left=[i for (i, c) in enumerate(b.line) if c in ["-", "^"]],
+                right=[i for (i, c) in enumerate(d.line) if c in ["+", "^"]],
+                newline=c.line,
                 skip_lines=3,
             )
 
+        # This represents the case where only additions are present in the edit
         pattern_b = [DiffLineCode.REMOVED, DiffLineCode.ADDED, DiffLineCode.MISSING]
         if self.__match_pattern(lines, pattern_b):
             return DiffChange(
                 left=[],
-                right=[i for (i, c) in enumerate(lines[2].line) if c in ["+", "^"]],
-                newline=lines[1].line,
+                right=[i for (i, c) in enumerate(c.line) if c in ["+", "^"]],
+                newline=b.line,
                 skip_lines=2,
             )
 
+        # This represents the case where only removals are present in the edit
         pattern_c = [DiffLineCode.REMOVED, DiffLineCode.MISSING, DiffLineCode.ADDED]
         if self.__match_pattern(lines, pattern_c):
             return DiffChange(
-                left=[i for (i, c) in enumerate(lines[1].line) for c in ["-", "^"]],
+                left=[i for (i, c) in enumerate(b.line) if c in ["-", "^"]],
                 right=[],
-                newline=lines[1].line,
+                newline=c.line,
                 skip_lines=2,
             )
 

test/test_diff_line.py

@@ -0,0 +1,39 @@
+from difflib_parser import diff_line
+
+
+def test_diff_line_parse_None():
+    line = diff_line.DiffLine.parse(None)
+    assert line is not None
+    assert line.code is None
+    assert line.line is None
+
+
+def test_diff_line_code_added():
+    line = diff_line.DiffLine.parse("+ ")
+    assert line is not None
+    assert line.code == diff_line.DiffLineCode.ADDED
+
+
+def test_diff_line_code_removed():
+    line = diff_line.DiffLine.parse("- ")
+    assert line is not None
+    assert line.code == diff_line.DiffLineCode.REMOVED
+
+
+def test_diff_line_code_common():
+    line = diff_line.DiffLine.parse("  ")
+    assert line is not None
+    assert line.code == diff_line.DiffLineCode.COMMON
+
+
+def test_diff_line_code_missing():
+    line = diff_line.DiffLine.parse("?  ")
+    assert line is not None
+    assert line.code == diff_line.DiffLineCode.MISSING
+
+
+def test_diff_line_line():
+    line = diff_line.DiffLine.parse("? Hello world!")
+    assert line is not None
+    assert line.code == diff_line.DiffLineCode.MISSING
+    assert line.line == "Hello world!"

test/test_difflib_parser.py

@@ -0,0 +1,52 @@
+from difflib_parser import difflib_parser
+
+
+def test_diff_parser_same_lines():
+    parser = difflib_parser.DiffParser(["Hello world"], ["Hello world"])
+    for diff in parser.iter_diffs():
+        assert diff.code == difflib_parser.DiffCode.SAME
+
+
+def test_diff_parser_added_line():
+    parser = difflib_parser.DiffParser([], ["Hello world"])
+    for diff in parser.iter_diffs():
+        assert diff.code == difflib_parser.DiffCode.RIGHT_ONLY
+
+
+def test_diff_parser_removed_line():
+    parser = difflib_parser.DiffParser(["Hello world"], [])
+    for diff in parser.iter_diffs():
+        assert diff.code == difflib_parser.DiffCode.LEFT_ONLY
+
+
+def test_diff_parser_changed_line_pattern_a():
+    # Pattern a essentially looks at the case where existing characters were added/removed
+    parser = difflib_parser.DiffParser(["Hello world"], ["Hola world"])
+    for diff in parser.iter_diffs():
+        assert diff.code == difflib_parser.DiffCode.CHANGED
+        assert diff.line == "Hello world"
+        assert diff.newline == "Hola world"
+        assert diff.left_changes == [1, 3, 4]
+        assert diff.right_changes == [1, 3]
+
+
+def test_diff_parser_changed_line_pattern_b():
+    # Pattern b essentially looks at the case where only additions were included
+    parser = difflib_parser.DiffParser(["Hello world"], ["Hello world!"])
+    for diff in parser.iter_diffs():
+        assert diff.code == difflib_parser.DiffCode.CHANGED
+        assert diff.line == "Hello world"
+        assert diff.newline == "Hello world!"
+        assert diff.left_changes == []
+        assert diff.right_changes == [11]
+
+
+def test_diff_parser_changed_line_pattern_c():
+    # Pattern c essentially looks at the case where only removals were included
+    parser = difflib_parser.DiffParser(["Hello world"], ["Hello worl"])
+    for diff in parser.iter_diffs():
+        assert diff.code == difflib_parser.DiffCode.CHANGED
+        assert diff.line == "Hello world"
+        assert diff.newline == "Hello worl"
+        assert diff.left_changes == [10]
+        assert diff.right_changes == []