Fixes all test (#400)

Co-authored-by: Ferdinand Neman <[email protected]>

editor/EvaluationRoute.go

@@ -80,7 +80,13 @@ func InitializeEvaluationRoute(router *mux.HyperMux) {
 		}
 
 		eng1 := &engine.GruleEngine{MaxCycle: 5}
-		kb := knowledgeLibrary.NewKnowledgeBaseInstance("Evaluator", "0.0.1")
+		kb, err := knowledgeLibrary.NewKnowledgeBaseInstance("Evaluator", "0.0.1")
+		if err != nil {
+			writer.WriteHeader(http.StatusBadRequest)
+			_, _ = writer.Write([]byte(fmt.Sprintf("Grule Error : %s", err.Error())))
+
+			return
+		}
 		err = eng1.Execute(dataContext, kb)
 		if err != nil {
 			writer.WriteHeader(http.StatusBadRequest)

editor/StaticRoute.go

@@ -2,9 +2,9 @@ package editor
 
 import (
 	"embed"
+	"github.com/hyperjumptech/grule-rule-engine/editor/mime"
 	mux "github.com/hyperjumptech/hyper-mux"
 	"github.com/sirupsen/logrus"
-	"grule-rule-engine/editor/mime"
 	"net/http"
 	"os"
 	"strings"

editor/cmd/Main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
+	"github.com/hyperjumptech/grule-rule-engine/editor"
 	"github.com/sirupsen/logrus"
-	"grule-rule-engine/editor"
 )
 
 func main() {

engine/GruleEngine_test.go

@@ -122,7 +122,8 @@ func TestGrule_Execute(t *testing.T) {
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(rules)))
 	assert.NoError(t, err)
 	engine := NewGruleEngine()
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	start := time.Now()
 	err = engine.Execute(dctx, kb)
 	assert.NoError(t, err)
@@ -158,7 +159,8 @@ func TestEngine_ExecuteErr(t *testing.T) {
 
 	engine := NewGruleEngine()
 	engine.ReturnErrOnFailedRuleEvaluation = true
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	err = engine.Execute(dctx, kb)
 	assert.Error(t, err)
 }
@@ -215,7 +217,8 @@ func TestEngine_ComplexRule1(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(complexRule1)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 
 	engine := NewGruleEngine()
 	err = engine.Execute(dctx, kb)
@@ -250,7 +253,8 @@ func TestEngine_ComplexRule2(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(complexRule2)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 
 	engine := NewGruleEngine()
 	err = engine.Execute(dctx, kb)
@@ -286,7 +290,8 @@ func TestEngine_ComplexRule3(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(complexRule3)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 
 	engine := NewGruleEngine()
 	err = engine.Execute(dctx, kb)
@@ -323,7 +328,8 @@ func TestEngine_ComplexRule4(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(complexRule4)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 
 	engine := NewGruleEngine()
 	err = engine.Execute(dctx, kb)
@@ -352,7 +358,8 @@ func TestEngine_OperatorPrecedence(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(OpPresedenceRule)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 
 	engine := NewGruleEngine()
 	err = engine.Execute(dctx, kb)
@@ -398,7 +405,8 @@ And another`
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(escapedRules)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 
 	assert.False(t, es.Result1)
 	assert.False(t, es.Result2)
@@ -439,7 +447,8 @@ rule KeepSleep "test string escaping" salience 10 {
 }
 `)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("TestTimer", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("TestTimer", "0.1.1")
+	assert.NoError(t, err)
 	engine := NewGruleEngine()
 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 	defer cancel()
@@ -514,7 +523,8 @@ func TestGruleEngine_FetchMatchingRules_Having_Same_Salience(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("conflict_rules_test", "0.1.1", pkg.NewBytesResource([]byte(duplicateRules)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("conflict_rules_test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("conflict_rules_test", "0.1.1")
+	assert.NoError(t, err)
 
 	//When
 	engine := NewGruleEngine()
@@ -537,7 +547,8 @@ func TestEngine_FetchMatchingRulesErr(t *testing.T) {
 
 	engine := NewGruleEngine()
 	engine.ReturnErrOnFailedRuleEvaluation = true
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	mr, err := engine.FetchMatchingRules(dctx, kb)
 	assert.Error(t, err)
 	assert.Nil(t, mr)
@@ -598,7 +609,8 @@ func TestGruleEngine_FetchMatchingRules_Having_Diff_Salience(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("conflict_rules_test", "0.1.1", pkg.NewBytesResource([]byte(duplicateRulesWithDiffSalience)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("conflict_rules_test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("conflict_rules_test", "0.1.1")
+	assert.NoError(t, err)
 
 	//When
 	engine := NewGruleEngine()
@@ -661,7 +673,8 @@ func TestGruleEngine_Follows_logical_operator_precedence(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("logical_operator_rules_test", "0.1.1", pkg.NewBytesResource([]byte(logicalOperatorPrecedenceRules)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("logical_operator_rules_test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("logical_operator_rules_test", "0.1.1")
+	assert.NoError(t, err)
 
 	//When
 	engine := NewGruleEngine()

examples/AgeCheckSample_test.go

@@ -82,7 +82,8 @@ func TestMyPoGo_GetStringLength(t *testing.T) {
 	ruleBuilder := builder.NewRuleBuilder(lib)
 	err = ruleBuilder.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(rule2)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 1}
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)
@@ -111,7 +112,8 @@ func TestMyPoGo_Compare(t *testing.T) {
 
 	err = ruleBuilder.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(rule3)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 100}
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)

examples/ArraySliceMap_test.go

@@ -103,7 +103,8 @@ rule SetTreeName "Set the top most tree name" {
 	ruleBuilder := builder.NewRuleBuilder(lib)
 	err = ruleBuilder.BuildRuleFromResource("TestFuncChaining", "0.0.1", pkg.NewBytesResource([]byte(rule)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("TestFuncChaining", "0.0.1")
+	kb, err := lib.NewKnowledgeBaseInstance("TestFuncChaining", "0.0.1")
+	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 1}
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)

examples/CallingFactFunctionExample_test.go

@@ -87,7 +87,9 @@ func TestCallingFactFunction(t *testing.T) {
 	lib := ast.NewKnowledgeLibrary()
 	ruleBuilder := builder.NewRuleBuilder(lib)
 	err = ruleBuilder.BuildRuleFromResource("CallingFactFunction", "0.1.1", pkg.NewBytesResource([]byte(CallFactFuncGRL)))
-	knowledgeBase := lib.NewKnowledgeBaseInstance("CallingFactFunction", "0.1.1")
+	assert.NoError(t, err)
+
+	knowledgeBase, err := lib.NewKnowledgeBaseInstance("CallingFactFunction", "0.1.1")
 	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 500}
 	err = eng1.Execute(dataContext, knowledgeBase)

examples/CallingLogExample_test.go

@@ -43,7 +43,8 @@ func TestCallingLog(t *testing.T) {
 	err := ruleBuilder.BuildRuleFromResource("CallingLog", "0.1.1", pkg.NewBytesResource([]byte(GRL)))
 	assert.NoError(t, err)
 
-	knowledgeBase := lib.NewKnowledgeBaseInstance("CallingLog", "0.1.1")
+	knowledgeBase, err := lib.NewKnowledgeBaseInstance("CallingLog", "0.1.1")
+	assert.NoError(t, err)
 
 	eng1 := &engine.GruleEngine{MaxCycle: 1}
 	err = eng1.Execute(dataContext, knowledgeBase)

examples/CloneTableIssue_test.go

@@ -36,7 +36,8 @@ func TestSliceFunctionPanicTest(t *testing.T) {
 	ruleBuilder := builder.NewRuleBuilder(knowledgeLibrary)
 	err = ruleBuilder.BuildRuleFromResource("test", "0.0.1", pkg.NewBytesResource([]byte(panickingRule)))
 	assert.NoError(t, err)
-	knowledgeBase := knowledgeLibrary.NewKnowledgeBaseInstance("test", "0.0.1")
+	knowledgeBase, err := knowledgeLibrary.NewKnowledgeBaseInstance("test", "0.0.1")
+	assert.NoError(t, err)
 	engine := engine.NewGruleEngine()
 
 	err = engine.Execute(dataContext, knowledgeBase)

examples/Concurrency_test.go

@@ -117,7 +117,7 @@ func beginThread(threadName string, lib *ast.KnowledgeLibrary, t *testing.T) {
 	engine := &engine.GruleEngine{MaxCycle: 100}
 
 	// Get an instance of our KnowledgeBase from KnowledgeLibrary
-	kb := lib.NewKnowledgeBaseInstance("VibonaciTest", "0.0.1")
+	kb, _ := lib.NewKnowledgeBaseInstance("VibonaciTest", "0.0.1")
 
 	// Execute the KnowledgeBase against DataContext
 	err = engine.Execute(dataContext, kb)

examples/EvaluateMissingDataContext_test.go

@@ -2,6 +2,7 @@ package examples
 
 import (
 	"fmt"
+	"github.com/stretchr/testify/assert"
 	"testing"
 
 	"github.com/hyperjumptech/grule-rule-engine/ast"
@@ -36,7 +37,8 @@ func TestDataContextMissingFact(t *testing.T) {
 
 	// 	add JSON fact
 	json := []byte(`{"blabla":"bla","name":{"first":"john","last":"doe"}}`)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.0.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.0.1")
+	assert.NoError(t, err)
 	dcx := ast.NewDataContext()
 
 	err = dcx.Add("R", oresult)

examples/FunctionCallChaining_test.go

@@ -74,7 +74,8 @@ rule SetTreeName "Set the top most tree name" {
 	ruleBuilder := builder.NewRuleBuilder(lib)
 	err = ruleBuilder.BuildRuleFromResource("TestFuncChaining", "0.0.1", pkg.NewBytesResource([]byte(rule)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("TestFuncChaining", "0.0.1")
+	kb, err := lib.NewKnowledgeBaseInstance("TestFuncChaining", "0.0.1")
+	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 1}
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)
@@ -119,7 +120,8 @@ rule SetTreeName "Set the top most tree name" {
 	ruleBuilder := builder.NewRuleBuilder(lib)
 	err = ruleBuilder.BuildRuleFromResource("TestFuncChaining", "0.0.1", pkg.NewBytesResource([]byte(rule)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("TestFuncChaining", "0.0.1")
+	kb, err := lib.NewKnowledgeBaseInstance("TestFuncChaining", "0.0.1")
+	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 1}
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)

examples/InterfaceDataContext_test.go

@@ -59,7 +59,8 @@ then
 	rb := builder.NewRuleBuilder(lib)
 	err := rb.BuildRuleFromResource("CarPriceTest", "0.1.1", pkg.NewBytesResource([]byte(rule)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("CarPriceTest", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("CarPriceTest", "0.1.1")
+	assert.NoError(t, err)
 	eng := &engine.GruleEngine{MaxCycle: 3}
 
 	dataContext := ast.NewDataContext()

examples/Issue108_test.go

@@ -74,7 +74,8 @@ func TestIssue108(t *testing.T) {
 	err = rb.BuildRuleFromResource("Test108", "0.0.1", pkg.NewBytesResource([]byte(Rule108)))
 	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 5}
-	kb := lib.NewKnowledgeBaseInstance("Test108", "0.0.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test108", "0.0.1")
+	assert.NoError(t, err)
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)
 	assert.Equal(t, 3, len(Obj.Sequence))

examples/Issue328_test.go

@@ -41,12 +41,14 @@ func TestMethodCall_SliceOOR(t *testing.T) {
 	assert.NoError(t, err)
 
 	eng1 := &engine.GruleEngine{MaxCycle: 5}
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)
 
 	eng1 = &engine.GruleEngine{MaxCycle: 5, ReturnErrOnFailedRuleEvaluation: true}
-	kb = lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err = lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	err = eng1.Execute(dataContext, kb)
 	assert.Error(t, err)
 }

examples/Issue4_test.go

@@ -70,7 +70,8 @@ func TestMethodCall_Issue4(t *testing.T) {
 	rb := builder.NewRuleBuilder(lib)
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(Rule4)))
 	assert.NoError(t, err)
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 3}
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)

examples/Issue5_test.go

@@ -62,7 +62,8 @@ func TestMethodCall_Issue5(t *testing.T) {
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(Rule)))
 	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 5}
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)
 	assert.Equal(t, "FromRuleScope3", user.GetName())

examples/Issue7_test.go

@@ -64,7 +64,8 @@ func TestMethodCall_Issue7(t *testing.T) {
 	err = rb.BuildRuleFromResource("Test", "0.1.1", pkg.NewBytesResource([]byte(Rule7)))
 	assert.NoError(t, err)
 	eng1 := &engine.GruleEngine{MaxCycle: 5}
-	kb := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Test", "0.1.1")
+	assert.NoError(t, err)
 	err = eng1.Execute(dataContext, kb)
 	assert.NoError(t, err)
 	assert.Equal(t, "FromRule", user.GetName())

examples/ItemArrayExample_test.go

@@ -87,7 +87,8 @@ func (cf *ItemPriceChecker) CheckPrices(t *testing.T) {
 	err := rb.BuildRuleFromResource("PriceCheck", "0.0.1", pkg.NewBytesResource([]byte(PriceCheckRule1)))
 	assert.NoError(t, err)
 
-	kb := lib.NewKnowledgeBaseInstance("PriceCheck", "0.0.1")
+	kb, err := lib.NewKnowledgeBaseInstance("PriceCheck", "0.0.1")
+	assert.NoError(t, err)
 
 	// Prepare the engine
 	eng := engine.NewGruleEngine()
@@ -168,7 +169,8 @@ func (cf *ItemPriceChecker) CheckCart(t *testing.T) {
 	err := rb.BuildRuleFromResource("Cart Check Rules", "0.0.1", pkg.NewBytesResource([]byte(PriceCheckRule2)))
 	assert.NoError(t, err)
 
-	kb := lib.NewKnowledgeBaseInstance("Cart Check Rules", "0.0.1")
+	kb, err := lib.NewKnowledgeBaseInstance("Cart Check Rules", "0.0.1")
+	assert.NoError(t, err)
 
 	// Prepare the engine
 	eng := engine.NewGruleEngine()