1
0
mirror of https://github.com/MontFerret/ferret.git synced 2024-12-23 01:24:30 +02:00
ferret/pkg/runtime/expressions/body_test.go
Tim Voronov 5620be211c
Next (#214)
* Renamed DOCUMENT to PAGE

* Added PageLoadParams

* Added PageLoadParams

* Renamed LoadPageParams -> PageLoadParams

* Added support for context.Done() (#201)

* Bug/#189 operators precedence (#202)

* Fixed math operators precedence

* Fixed logical operators precedence

* Fixed array operator

* Added support for parentheses to enforce a different operator evaluation order

* Feature/#200 drivers (#209)

* Added new interfaces

* Renamed dynamic to cdp driver

* Renamed drivers

* Added ELEMENT_EXISTS function (#210)

* Renamed back PAGE to DOCUMENT (#211)

* Added Getter and Setter interfaces
2018-12-21 23:14:41 -05:00

148 lines
4.0 KiB
Go

package expressions_test
import (
"context"
"testing"
"github.com/MontFerret/ferret/pkg/runtime/core"
"github.com/MontFerret/ferret/pkg/runtime/expressions"
"github.com/MontFerret/ferret/pkg/runtime/values"
. "github.com/smartystreets/goconvey/convey"
)
func TestBody(t *testing.T) {
Convey("Should create a block expression", t, func() {
s := expressions.NewBodyExpression(1)
So(s, ShouldHaveSameTypeAs, &expressions.BodyExpression{})
})
Convey("Should add a new expression of a default type", t, func() {
s := expressions.NewBodyExpression(0)
sourceMap := core.NewSourceMap("test", 1, 1)
exp, err := expressions.NewVariableExpression(sourceMap, "testExp")
So(err, ShouldBeNil)
err = s.Add(exp)
So(err, ShouldBeNil)
})
Convey("Should add a new Return expression", t, func() {
s := expressions.NewBodyExpression(0)
sourceMap := core.NewSourceMap("test", 1, 1)
predicate, err := expressions.NewVariableExpression(sourceMap, "testExp")
So(err, ShouldBeNil)
exp, err := expressions.NewReturnExpression(sourceMap, predicate)
So(err, ShouldBeNil)
err = s.Add(exp)
So(err, ShouldBeNil)
})
Convey("Should not add an already defined Return expression", t, func() {
s := expressions.NewBodyExpression(0)
sourceMap := core.NewSourceMap("test", 1, 1)
predicate, err := expressions.NewVariableExpression(sourceMap, "testExp")
So(err, ShouldBeNil)
exp, err := expressions.NewReturnExpression(sourceMap, predicate)
So(err, ShouldBeNil)
err = s.Add(exp)
So(err, ShouldBeNil)
err = s.Add(exp)
So(err, ShouldBeError)
So(err.Error(), ShouldEqual, "invalid operation: return expression is already defined")
})
Convey("Should exec a block expression", t, func() {
s := expressions.NewBodyExpression(1)
sourceMap := core.NewSourceMap("test", 1, 1)
predicate, err := expressions.NewVariableExpression(sourceMap, "test")
So(err, ShouldBeNil)
retexp, err := expressions.NewReturnExpression(sourceMap, predicate)
So(err, ShouldBeNil)
err = s.Add(retexp)
So(err, ShouldBeNil)
rootScope, fn := core.NewRootScope()
scope := rootScope.Fork()
scope.SetVariable("test", values.NewString("value"))
fn()
value, err := s.Exec(context.Background(), scope)
So(err, ShouldBeNil)
So(value, ShouldNotBeNil)
So(value, ShouldEqual, "value")
})
Convey("Should not found a missing statement", t, func() {
s := expressions.NewBodyExpression(1)
sourceMap := core.NewSourceMap("test", 1, 1)
predicate, err := expressions.NewVariableExpression(sourceMap, "testExp")
So(err, ShouldBeNil)
exp, err := expressions.NewReturnExpression(sourceMap, predicate)
So(err, ShouldBeNil)
err = s.Add(exp)
So(err, ShouldBeNil)
rootScope, fn := core.NewRootScope()
scope := rootScope.Fork()
scope.SetVariable("test", values.NewString("value"))
fn()
value, err := s.Exec(context.Background(), scope)
So(err, ShouldNotBeNil)
So(err, ShouldHaveSameTypeAs, core.ErrNotFound)
So(value, ShouldHaveSameTypeAs, values.None)
})
Convey("Should not exec a nil block expression", t, func() {
s := expressions.NewBodyExpression(1)
sourceMap := core.NewSourceMap("test", 1, 1)
exp, err := expressions.NewVariableExpression(sourceMap, "test")
So(err, ShouldBeNil)
err = s.Add(exp)
So(err, ShouldBeNil)
rootScope, fn := core.NewRootScope()
scope := rootScope.Fork()
scope.SetVariable("test", values.NewString("value"))
fn()
value, err := s.Exec(context.Background(), scope)
So(err, ShouldBeNil)
So(value, ShouldHaveSameTypeAs, values.None)
})
Convey("Should stop an execution when context is cancelled", t, func() {
s := expressions.NewBodyExpression(1)
sourceMap := core.NewSourceMap("test", 1, 1)
exp, _ := expressions.NewVariableExpression(sourceMap, "test")
s.Add(exp)
rootScope, _ := core.NewRootScope()
scope := rootScope.Fork()
scope.SetVariable("test", values.NewString("value"))
ctx, cancel := context.WithCancel(context.Background())
cancel()
_, err := s.Exec(ctx, scope)
So(err, ShouldEqual, core.ErrTerminated)
})
}