#12 add tests for expression tree builder

.mockery.yaml

@@ -11,3 +11,4 @@ packages:
       Builder:
       Tokenizer:
       node:
+      ExpressionTreeFactory:

internal/rule/expression_tree.go

@@ -9,7 +9,8 @@ type ExpressionTreeBuilder interface {
 }
 
 type expressionTreeBuilder struct {
-	tokenizer Tokenizer
+	tokenizer             Tokenizer
+	expressionTreeFactory ExpressionTreeFactory
 }
 
 var _ ExpressionTreeBuilder = (*expressionTreeBuilder)(nil)
@@ -21,10 +22,15 @@ func newCustomRulesTokenizer() *expressionTreeBuilder {
 }
 
 func (c *expressionTreeBuilder) BuildExpressionTree(variable, expression string) (expressionTree, error) {
-	_, err := c.tokenizer.BuildTokens(variable, expression)
+	tokens, err := c.tokenizer.BuildTokens(variable, expression)
 	if err != nil {
 		return nil, fmt.Errorf("build tokens: %w", err)
 	}
 
-	return nil, nil
+	tree, err := c.expressionTreeFactory.CreateExpressionTree(tokens)
+	if err != nil {
+		return nil, fmt.Errorf("create expression tree: %w", err)
+	}
+
+	return tree, nil
 }

internal/rule/expression_tree_test.go

@@ -0,0 +1,118 @@
+package rule
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+)
+
+func Test_expressionTreeBuilder_BuildExpressionTree(t *testing.T) {
+	type fields struct {
+		tokenizerFunc             func() Tokenizer
+		expressionTreeFactoryFunc func() ExpressionTreeFactory
+	}
+	type args struct {
+		variable   string
+		expression string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    expressionTree
+		wantErr bool
+	}{
+		{
+			name: "tokenizer returns error, error returned",
+			fields: fields{
+				tokenizerFunc: func() Tokenizer {
+					tkn := NewMockTokenizer(t)
+
+					tkn.EXPECT().
+						BuildTokens(mock.Anything, mock.Anything).
+						Return(nil, errors.New("error"))
+
+					return tkn
+				},
+			},
+			wantErr: true,
+		},
+		{
+			name: "expression tree factory returns error, error returned",
+			fields: fields{
+				tokenizerFunc: func() Tokenizer {
+					tkn := NewMockTokenizer(t)
+
+					tkn.EXPECT().
+						BuildTokens(mock.Anything, mock.Anything).
+						Return(testTokens, nil)
+
+					return tkn
+				},
+				expressionTreeFactoryFunc: func() ExpressionTreeFactory {
+					etf := NewMockExpressionTreeFactory(t)
+
+					etf.EXPECT().
+						CreateExpressionTree(mock.Anything).
+						Return(nil, errors.New("error"))
+
+					return etf
+				},
+			},
+			wantErr: true,
+		},
+		{
+			name: "expression tree factory returns expression tree, tree returned",
+			fields: fields{
+				tokenizerFunc: func() Tokenizer {
+					tkn := NewMockTokenizer(t)
+
+					tkn.EXPECT().
+						BuildTokens(mock.Anything, mock.Anything).
+						Return(testTokens, nil)
+
+					return tkn
+				},
+				expressionTreeFactoryFunc: func() ExpressionTreeFactory {
+					etf := NewMockExpressionTreeFactory(t)
+
+					etf.EXPECT().
+						CreateExpressionTree(testTokens).
+						Return(and{}, nil)
+
+					return etf
+				},
+			},
+			wantErr: false,
+			want:    and{},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var expressionTreeFactory ExpressionTreeFactory
+			if tt.fields.expressionTreeFactoryFunc != nil {
+				expressionTreeFactory = tt.fields.expressionTreeFactoryFunc()
+			}
+
+			var tokenizer Tokenizer
+			if tt.fields.tokenizerFunc != nil {
+				tokenizer = tt.fields.tokenizerFunc()
+			}
+
+			c := &expressionTreeBuilder{
+				tokenizer:             tokenizer,
+				expressionTreeFactory: expressionTreeFactory,
+			}
+			got, err := c.BuildExpressionTree(tt.args.variable, tt.args.expression)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("BuildExpressionTree() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("BuildExpressionTree() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/rule/factory.go

@@ -0,0 +1,5 @@
+package rule
+
+type ExpressionTreeFactory interface {
+	CreateExpressionTree(tokens []Token) (expressionTree, error)
+}