improve coverage

Technologicat · Technologicat · commit 4cd324c91628 · 2020-08-25T02:38:54.000+03:00
diff --git a/unpythonic/seq.py b/unpythonic/seq.py
@@ -145,7 +145,7 @@ def pipe1(value0, *bodys):
 
 class Getvalue(Singleton):  # singleton sentinel with a nice repr
     """Sentinel; pipe into this to exit a shell-like pipe and return the current value."""
-    def __repr__(self):
+    def __repr__(self):  # pragma: no cover
         return "<sentinel for pipe exit>"
 getvalue = Getvalue()
 runpipe = getvalue  # same thing as getvalue, but semantically better name for lazy pipes
@@ -185,7 +185,7 @@ def __or__(self, f):
             return self._x
         cls = self.__class__
         return cls(f(self._x))  # functional update
-    def __repr__(self):
+    def __repr__(self):  # pragma: no cover
         return "<piped1 at 0x{:x}; value {}>".format(id(self), self._x)
 
 class lazy_piped1:
@@ -247,7 +247,7 @@ def nextfibo(state):
         # just pass on the reference to the original x.
         cls = self.__class__
         return cls(x=self._x, _funcs=self._funcs + (f,))
-    def __repr__(self):
+    def __repr__(self):  # pragma: no cover
         return "<lazy_piped1 at 0x{:x}; initial value now {}, functions {}>".format(id(self), self._x, self._funcs)
 
 def pipe(values0, *bodys):
@@ -330,14 +330,12 @@ def __or__(self, f):
         if f is exitpipe:
             return xs if len(xs) > 1 else xs[0]
         cls = self.__class__
-        if isinstance(xs, tuple):
-            newxs = f(*xs)
-        else:
-            newxs = f(xs)
+        assert isinstance(xs, tuple)  # __init__ ensures this
+        newxs = f(*xs)
         if isinstance(newxs, tuple):
             return cls(*newxs)
         return cls(newxs)
-    def __repr__(self):
+    def __repr__(self):  # pragma: no cover
         return "<piped at 0x{:x}; values {}>".format(id(self), self._xs)
 
 class lazy_piped:
@@ -379,11 +377,14 @@ def __or__(self, f):
                     vs = g(*vs)
                 else:
                     vs = g(vs)
-            return vs if len(vs) > 1 else vs[0]
+            if isinstance(vs, tuple):
+                return vs if len(vs) > 1 else vs[0]
+            else:
+                return vs
         # just pass on the references to the original xs.
         cls = self.__class__
         return cls(*self._xs, _funcs=self._funcs + (f,))
-    def __repr__(self):
+    def __repr__(self):  # pragma: no cover
         return "<lazy_piped at 0x{:x}; initial values now {}, functions {}>".format(id(self), self._xs, self._funcs)
 
 # do(): improved begin() that can name intermediate results and refer to them
@@ -485,7 +486,7 @@ def maybe_call(v):
             try:
                 if not arity_includes(v, 1):
                     raise ValueError("Arity mismatch; callable value must allow arity 1, to take in the environment.")
-            except UnknownArity:  # well, we tried!
+            except UnknownArity:  # well, we tried!  # pragma: no cover
                 pass
             return v(e)
         return v
diff --git a/unpythonic/test/test_seq.py b/unpythonic/test/test_seq.py
@@ -27,6 +27,12 @@ def runtests():
                                    lambda: print("cheeky side effect"))
         test[f4(2) == 84]
 
+        # special cases
+        test[lazy_begin() is None]
+        test[lazy_begin(lambda: 42) == 42]
+        test[lazy_begin0() is None]
+        test[lazy_begin0(lambda: 42) == 42]
+
     # pipe: sequence functions
     with testset("pipe (sequence functions)"):
         double = lambda x: 2 * x
@@ -127,6 +133,9 @@ def nextfibo(a, b):    # now two arguments
         p | exitpipe
         test[fibos == [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]]
 
+        # abuse multi-arg version for single-arg case
+        test[lazy_piped(42) | double | inc | exitpipe == 85]
+
     # do: improved begin() that can name intermediate results
     with testset("do (code imperatively in expressions)"):
         y = do(assign(x=17),
@@ -194,6 +203,10 @@ def nextfibo(a, b):    # now two arguments
                        lambda e: fail["This line should not be reached."]))  # and this (as above)  # pragma: no cover
         test[z == 42]
 
+    with testset("do error cases"):
+        test_raises[ValueError, do(lambda e: assign(x=2, y=3))]  # expect only one binding per assign()
+        test_raises[ValueError, do(lambda: 42)]  # missing the env parameter
+
 if __name__ == '__main__':  # pragma: no cover
     with session(__file__):
         runtests()
