Tests range

pkg/runtime/expressions/operators/range_test.go

@@ -0,0 +1,107 @@
+package operators_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/MontFerret/ferret/pkg/runtime/core"
+	"github.com/MontFerret/ferret/pkg/runtime/expressions/operators"
+	"github.com/MontFerret/ferret/pkg/runtime/values"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+type MockExpressionInt int
+
+func (e MockExpressionInt) Exec(_ context.Context, _ *core.Scope) (core.Value, error) {
+	return values.NewInt(int(e)), nil
+}
+
+type MockExpressionFloat float64
+
+func (e MockExpressionFloat) Exec(_ context.Context, _ *core.Scope) (core.Value, error) {
+	return values.NewFloat(float64(e)), nil
+}
+
+type MockExpressionString string
+
+func (e MockExpressionString) Exec(_ context.Context, _ *core.Scope) (core.Value, error) {
+	return values.NewString(string(e)), nil
+}
+
+type FailingMockExpression int
+
+func (e FailingMockExpression) Exec(_ context.Context, _ *core.Scope) (core.Value, error) {
+	return nil, errors.New("MockError")
+}
+
+var sourceMap = core.NewSourceMap("hello", 2, 3)
+var rootScope, _ = core.NewRootScope()
+
+func TestRangeOperator(t *testing.T) {
+	var correctEx MockExpressionInt = 10
+	var failEx FailingMockExpression = 0
+	Convey("NewRangeOperator", t, func() {
+		Convey("Should return *RangeOperator, given correct arguments", func() {
+			res, _ := operators.NewRangeOperator(sourceMap, correctEx, correctEx)
+			So(res, ShouldHaveSameTypeAs, &operators.RangeOperator{})
+		})
+		Convey("Should return error if no left operator is given", func() {
+			_, err := operators.NewRangeOperator(sourceMap, nil, correctEx)
+			So(err, ShouldHaveSameTypeAs, core.ErrMissedArgument)
+		})
+		Convey("Should return error if no right operator is given", func() {
+			_, err := operators.NewRangeOperator(sourceMap, correctEx, nil)
+			So(err, ShouldHaveSameTypeAs, core.ErrMissedArgument)
+		})
+	})
+	Convey(".Exec", t, func() {
+		Convey("Should return error if left expression fails", func() {
+			rangeOp, _ := operators.NewRangeOperator(sourceMap, failEx, correctEx)
+			_, err := rangeOp.Exec(context.TODO(), rootScope)
+			So(err, ShouldHaveSameTypeAs, &core.SourceErrorDetail{})
+		})
+		Convey("Should return error if right expression fails", func() {
+			rangeOp, _ := operators.NewRangeOperator(sourceMap, correctEx, failEx)
+			_, err := rangeOp.Exec(context.TODO(), rootScope)
+			So(err, ShouldHaveSameTypeAs, &core.SourceErrorDetail{})
+		})
+	})
+	Convey(".Eval", t, func() {
+		var stringEx MockExpressionString = "noInt/noFloat"
+		/* 		var intExZero MockExpressionInt = 0
+		   		var intExTwenty MockExpressionInt = 20
+		   		var floatExNegative MockExpressionFloat = -2.2
+		   		var floatExPositive MockExpressionFloat = 12.4 */
+		Convey("Should return error if given non int/float left Expression", func() {
+			rangeOp, _ := operators.NewRangeOperator(sourceMap, stringEx, correctEx)
+			_, err := rangeOp.Exec(context.TODO(), rootScope)
+			So(err, ShouldHaveSameTypeAs, &core.SourceErrorDetail{})
+		})
+		Convey("Should return error if given non int/float right Expression", func() {
+			rangeOp, _ := operators.NewRangeOperator(sourceMap, correctEx, stringEx)
+			_, err := rangeOp.Exec(context.TODO(), rootScope)
+			So(err, ShouldHaveSameTypeAs, &core.SourceErrorDetail{})
+		})
+		Convey("Should return Array with range [start,...end] given ints", func() {
+			var start MockExpressionInt = 1
+			var end MockExpressionInt = 14
+
+			rangeOp, _ := operators.NewRangeOperator(sourceMap, start, end)
+			arr, err := rangeOp.Exec(context.TODO(), rootScope)
+			So(err, ShouldHaveSameTypeAs, nil)
+			So(arr, ShouldHaveSameTypeAs, &values.Array{})
+			So(arr.String(), ShouldEqual, "[1,2,3,4,5,6,7,8,9,10,11,12,13,14]")
+		})
+		Convey("Should return Array with range [start,...end] given floats", func() {
+			var start MockExpressionFloat = -2.2
+			var end MockExpressionFloat = 12.4
+
+			rangeOp, _ := operators.NewRangeOperator(sourceMap, start, end)
+			arr, err := rangeOp.Exec(context.TODO(), rootScope)
+			So(err, ShouldHaveSameTypeAs, nil)
+			So(arr, ShouldHaveSameTypeAs, &values.Array{})
+			So(arr.String(), ShouldEqual, "[-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12]")
+		})
+	})
+}

pkg/runtime/expressions/variable_test.go

@@ -0,0 +1,69 @@
+package expressions_test
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+
+	"github.com/MontFerret/ferret/pkg/runtime/core"
+	"github.com/MontFerret/ferret/pkg/runtime/expressions"
+	"github.com/MontFerret/ferret/pkg/runtime/values"
+)
+var sourceMap = core.NewSourceMap("hello", 2, 3)
+var rootScope, _ = core.NewRootScope()
+var _ = rootScope.SetVariable("key", values.NewString("value"))
+
+func TestNewVariableExpression(t *testing.T) {
+
+	Convey("Should not throw error and create a VariableExpression given correct arguments", t, func() {
+		ret, err := expressions.NewVariableExpression(sourceMap, "foo")
+
+		So(ret, ShouldHaveSameTypeAs, &expressions.VariableExpression{})
+		So(err, ShouldBeNil)
+	})
+
+	Convey("Should throw error when given no name argument", t, func() {
+		_, err := expressions.NewVariableExpression(sourceMap, "")
+
+		So(err, ShouldHaveSameTypeAs, core.ErrMissedArgument)
+	})
+
+	Convey("Calling .Exec should return the correct variable set in the given scope", t, func() {
+		ret, _ := expressions.NewVariableExpression(sourceMap, "key")
+		value, err := ret.Exec(context.TODO(), rootScope)
+
+		So(value, ShouldEqual, "value")
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestNewVariableDeclarationExpression(t *testing.T) {
+	Convey("Should not throw error and create a NewVariableDeclarationExpression given correct arguments", t, func() {
+		variableExpression, _ := expressions.NewVariableExpression(sourceMap, "foo")
+		ret, err := expressions.NewVariableDeclarationExpression(sourceMap, "test", variableExpression)
+
+		So(ret, ShouldHaveSameTypeAs, &expressions.VariableDeclarationExpression{})
+		So(err, ShouldBeNil)
+	})
+
+	Convey("Should throw error if init argument is nil", t, func() {
+		_, err := expressions.NewVariableDeclarationExpression(sourceMap, "test", nil)
+
+		So(err, ShouldHaveSameTypeAs, core.ErrMissedArgument)
+	})
+
+	Convey("Calling .Exec should add the value retrieved by its VariableExpression with its own name as key to the given scope", t, func() {
+		variableExpression, _ := expressions.NewVariableExpression(sourceMap, "key")
+		variableDeclarationExpression, _ := expressions.NewVariableDeclarationExpression(sourceMap, "keyTwo", variableExpression)
+		_, err := variableDeclarationExpression.Exec(context.TODO(), rootScope)
+
+		So(err, ShouldBeNil)
+
+		value, _ := rootScope.GetVariable("key")
+		value2, _ := rootScope.GetVariable("keyTwo")
+
+		So(value, ShouldEqual, "value")
+		So(value2, ShouldEqual, "value")
+	})
+}