Push test coverage to 100% and bump version (#18)

* push test coverage to 100%

* bump version

* maintain tokens inside pointer as a tuple

* add test for Pointer.append

Author: Korijn

patchdiff/__init__.py

@@ -2,4 +2,4 @@
 from .diff import diff
 from .serialize import to_json
 
-__version__ = "0.3.3"
+__version__ = "0.3.4"

patchdiff/pointer.py

@@ -22,18 +22,18 @@ class Pointer:
     def __init__(self, tokens: List[Hashable] = None) -> None:
         if tokens is None:
             tokens = []
-        self.tokens = tokens
+        self.tokens = tuple(tokens)
 
     @staticmethod
     def from_str(path: str) -> "Pointer":
-        tokens = [unescape(t) for t in path.split("/")]
+        tokens = [unescape(t) for t in path.split("/")[1:]]
         return Pointer(tokens)
 
     def __str__(self) -> str:
         return "/" + "/".join(escape(str(t)) for t in self.tokens)
 
     def __repr__(self) -> str:
-        return f"Pointer({repr(self.tokens)})"
+        return f"Pointer({repr(list(self.tokens))})"
 
     def __hash__(self) -> int:
         return hash(self.tokens)
@@ -62,4 +62,4 @@ def evaluate(self, obj: Diffable) -> Tuple[Diffable, Hashable, Any]:
 
     def append(self, token: Hashable) -> "Pointer":
         """append, creating new Pointer"""
-        return Pointer(self.tokens + [token])
+        return Pointer(self.tokens + (token,))

patchdiff/types.py

@@ -1,3 +1,3 @@
-from typing import Dict, List, Set, Tuple, Union
+from typing import Dict, List, Set, Union
 
-Diffable = Union[Dict, List, Set, Tuple]
+Diffable = Union[Dict, List, Set]

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "patchdiff"
-version = "0.3.3"
+version = "0.3.4"
 description = "MIT"
 authors = ["Korijn van Golen <[email protected]>", "Berend Klein Haneveld <[email protected]>"]
 homepage = "https://github.com/fork-tongue/patchdiff"

tests/test_pointer.py

@@ -10,3 +10,37 @@ def test_pointer_get():
 def test_pointer_str():
     assert str(Pointer([1])) == "/1"
     assert str(Pointer(["foo", "bar", "-"])) == "/foo/bar/-"
+
+
+def test_pointer_repr():
+    assert repr(Pointer([1])) == "Pointer([1])"
+    assert repr(Pointer(["foo", "bar", "-"])) == "Pointer(['foo', 'bar', '-'])"
+
+
+def test_pointer_from_str():
+    assert Pointer.from_str("/1") == Pointer(["1"])
+    assert Pointer.from_str("/foo/bar/-") == Pointer(["foo", "bar", "-"])
+
+
+def test_pointer_hash():
+    assert hash(Pointer([1])) == hash((1,))
+    assert hash(Pointer(["foo", "bar", "-"])) == hash(("foo", "bar", "-"))
+
+
+def test_pointer_set():
+    # hash supports comparison operators for use as keys and set elements
+    # so we exercise that as well
+    unique_pointers = [Pointer([1]), Pointer(["2", "3"])]
+    duplicated_pointers = unique_pointers + unique_pointers
+    assert len(set(duplicated_pointers)) == len(unique_pointers)
+
+
+def test_pointer_eq():
+    assert Pointer([1]) != [1]
+    assert Pointer([1]) != Pointer(["1"])
+    assert Pointer([1]) != Pointer([0])
+    assert Pointer([1]) == Pointer([1])
+
+
+def test_pointer_append():
+    assert Pointer([1]).append("foo") == Pointer([1, "foo"])