Improves expression tests

jamillosantos · Dec 5, 2017 · 55b10f6 · 55b10f6
1 parent b0e16ec
commit 55b10f6
Show file tree

Hide file tree

Showing 2 changed files with 41 additions and 5 deletions.
diff --git a/expression.go b/expression.go
@@ -86,12 +86,8 @@ func (e *ExpressionMultiple) Solve(ctx Context) (interface{}, error) {
 				return nil, err
 			}
 			switch rr := rTemp.(type) {
-			case int:
-				r = float64(rr)
 			case float64:
 				r = rr
-			default:
-				return nil, NewWrongTypeError(rTemp)
 			}
 			result = r
 		}

diff --git a/expression_test.go b/expression_test.go
@@ -83,7 +83,18 @@ func TestExpressions(t *testing.T) {
 				Expect(r).To(Equal(float64(3)))
 			})
 
-			g.It("should fail addition due to wrong data type", func() {
+			g.It("should fail addition due to wrong data type (1st param)", func() {
+				v := expressions.NewExpressionMultiple()
+				ctx := expressions.NewContext(nil, nil)
+				v.Add("", expressions.NewExpressionValue("string cannot be added"))
+				v.Add("+", expressions.NewExpressionValue(1))
+				Expect(v).NotTo(BeNil())
+				_, err := v.Solve(ctx)
+				Expect(err).NotTo(BeNil())
+				Expect(fmt.Sprint(err)).To(ContainSubstring("not a valid type"))
+			})
+
+			g.It("should fail addition due to wrong data type (2nd param)", func() {
 				v := expressions.NewExpressionMultiple()
 				ctx := expressions.NewContext(nil, nil)
 				v.Add("", expressions.NewExpressionValue(1))
@@ -399,6 +410,17 @@ func TestExpressions(t *testing.T) {
 				Expect(v).NotTo(BeNil())
 			})
 
+			g.It("should fail due to invalid operator", func() {
+				expr := expressions.NewExpressionBinary(expressions.NewExpressionValue(1), "invalid operator", expressions.NewExpressionValue(3))
+				ctx := expressions.NewContext(nil, nil)
+				Expect(expr).NotTo(BeNil())
+				_, err := expr.Solve(ctx)
+				Expect(err).NotTo(BeNil())
+				Expect(fmt.Sprint(err)).To(ContainSubstring("The operator"))
+				Expect(fmt.Sprint(err)).To(ContainSubstring("invalid operator"))
+				Expect(fmt.Sprint(err)).To(ContainSubstring("is not supported"))
+			})
+
 			g.Describe("< (lower than)", func() {
 				g.It("should solve true with integer parameters", func() {
 					expr := expressions.NewExpressionBinary(expressions.NewExpressionValue(1), "<", expressions.NewExpressionValue(3))
@@ -492,6 +514,24 @@ func TestExpressions(t *testing.T) {
 					Expect(r).To(BeFalse())
 				})
 
+				g.It("should fail due to wrong data type (1st param)", func() {
+					expr := expressions.NewExpressionBinary(expressions.NewExpressionValue("invalid"), ">", expressions.NewExpressionValue(3.5))
+					ctx := expressions.NewContext(nil, nil)
+					Expect(expr).NotTo(BeNil())
+					_, err := expr.Solve(ctx)
+					Expect(err).NotTo(BeNil())
+					Expect(fmt.Sprint(err)).To(ContainSubstring("not a valid type"))
+				})
+
+				g.It("should fail due to wrong data type (1st param)", func() {
+					expr := expressions.NewExpressionBinary(expressions.NewExpressionValue(1), ">", expressions.NewExpressionValue("invalid"))
+					ctx := expressions.NewContext(nil, nil)
+					Expect(expr).NotTo(BeNil())
+					_, err := expr.Solve(ctx)
+					Expect(err).NotTo(BeNil())
+					Expect(fmt.Sprint(err)).To(ContainSubstring("not a valid type"))
+				})
+
 				g.It("should fail with injected expression solving error (1st param)", func() {
 					expr := expressions.NewExpressionBinary(&ExpressionFail{}, ">", expressions.NewExpressionValue(1.5))
 					ctx := expressions.NewContext(nil, nil)