added tests to improve code coverage

Author: Robbie Muir

doc/release_notes.rst

@@ -4,6 +4,7 @@ Release Notes
 Future Version
 ---------------
 **Minor Improvements**
+
 * Improved variable/expression arithmetic methods so that they correctly handle types
 
 Upcoming Version

linopy/expressions.py

@@ -1317,7 +1317,7 @@ def __add__(
 
     def __radd__(self, other: ConstantLike) -> LinearExpression:
         try:
-            return self.__add__(other)
+            return self + other
         except TypeError:
             return NotImplemented
 
@@ -1345,7 +1345,7 @@ def __sub__(
 
     def __rsub__(self, other: ConstantLike | Variable) -> LinearExpression:
         try:
-            return self.__neg__().__add__(other)
+            return (self * -1) + other
         except TypeError:
             return NotImplemented
 
@@ -1389,7 +1389,7 @@ def __rmul__(self, other: ConstantLike) -> LinearExpression:
         Right-multiply the expr by a factor.
         """
         try:
-            return self.__mul__(other)
+            return self * other
         except TypeError:
             return NotImplemented
 
@@ -1725,7 +1725,7 @@ def __mul__(self, other: SideLike) -> QuadraticExpression:
             return NotImplemented
 
     def __rmul__(self, other: SideLike) -> QuadraticExpression:
-        return self.__mul__(other)
+        return self * other
 
     def __add__(self, other: SideLike) -> QuadraticExpression:
         """
@@ -1776,7 +1776,7 @@ def __rsub__(self, other: SideLike) -> QuadraticExpression:
         Subtract expression from others.
         """
         try:
-            return self.__neg__().__add__(other)
+            return (self * -1) + other
         except TypeError:
             return NotImplemented
 

linopy/variables.py

@@ -1516,8 +1516,7 @@ class ScalarVariable:
     """
     A scalar variable container.
 
-    In contrast to the Variable class, a ScalarVariable only contains
-    only one label. Use this class to create a expression or constraint
+    In contrast to the Variable class, a ScalarVariable only contains one label. Use this class to create a expression or constraint
     in a rule.
     """
 

test/test_linear_expression.py

@@ -18,6 +18,7 @@
 from linopy.constants import HELPER_DIMS, TERM_DIM
 from linopy.expressions import ScalarLinearExpression
 from linopy.testing import assert_linequal, assert_quadequal
+from linopy.variables import ScalarVariable
 
 
 @pytest.fixture
@@ -227,6 +228,8 @@ def test_linear_expression_with_multiplication(x: Variable) -> None:
     with pytest.raises(TypeError):
         quad * quad
 
+    expr = x * 1
+    assert isinstance(expr, LinearExpression)
     assert expr.__mul__(object()) is NotImplemented
     assert expr.__rmul__(object()) is NotImplemented
 
@@ -285,6 +288,7 @@ def test_linear_expression_rsubtraction(x: Variable, y: Variable) -> None:
     assert isinstance(expr_2, LinearExpression)
     expr_3: LinearExpression = (expr - 10.0) * -1
     assert_linequal(expr_2, expr_3)
+    assert expr.__rsub__(object()) is NotImplemented
 
 
 def test_linear_expression_with_constant(m: Model, x: Variable, y: Variable) -> None:
@@ -494,14 +498,15 @@ def test_linear_expression_sum_warn_unknown_kwargs(z: Variable) -> None:
 
 
 def test_linear_expression_power(x: Variable) -> None:
-    qd_expr = x**2
+    expr: LinearExpression = x * 1.0
+    qd_expr = expr**2
     assert isinstance(qd_expr, QuadraticExpression)
 
-    qd_expr2 = x.pow(2)
+    qd_expr2 = expr.pow(2)
     assert_quadequal(qd_expr, qd_expr2)
 
     with pytest.raises(ValueError):
-        x**3
+        expr**3
 
 
 def test_linear_expression_multiplication(
@@ -1085,13 +1090,31 @@ def test_linear_expression_from_tuples(x: Variable, y: Variable) -> None:
 
     expr4 = LinearExpression.from_tuples((10, x), (1, y), 1)
     assert isinstance(expr4, LinearExpression)
+    assert (expr4.const == 1).all()
+
+    expr5 = LinearExpression.from_tuples(1, model=x.model)
+    assert isinstance(expr5, LinearExpression)
 
+
+def test_linear_expression_from_tuples_bad_calls(
+    m: Model, x: Variable, y: Variable
+) -> None:
     with pytest.raises(ValueError):
         LinearExpression.from_tuples((10, x), (1, y), x)
 
     with pytest.raises(ValueError):
         LinearExpression.from_tuples((10, x, 3), (1, y), 1)
 
+    sv = ScalarVariable(label=0, model=m)
+    with pytest.raises(TypeError):
+        LinearExpression.from_tuples((np.array([1, 1]), sv))
+
+    with pytest.raises(TypeError):
+        LinearExpression.from_tuples((x, x))
+
+    with pytest.raises(ValueError):
+        LinearExpression.from_tuples(10)
+
 
 def test_linear_expression_sanitize(x: Variable, y: Variable, z: Variable) -> None:
     expr = 10 * x + y + z

test/test_quadratic_expression.py

@@ -123,6 +123,9 @@ def test_matmul_expr_and_expr(x: Variable, y: Variable, z: Variable) -> None:
     assert expr.nterm == 6
     assert_quadequal(expr, target)
 
+    with pytest.raises(TypeError):
+        (x**2) @ (y**2)
+
 
 def test_matmul_with_const(x: Variable) -> None:
     expr = x * x