#12 add some tests to expressions

.mockery.yaml

@@ -8,4 +8,5 @@ inpackage: True
 packages:
   waffle/internal/rule:
     interfaces:
-      Builder:
+      Builder:
+      node:

internal/rule/expression_test.go

@@ -0,0 +1,174 @@
+package rule
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+
+	"waffle/internal/request"
+)
+
+func Test_and_Eval(t *testing.T) {
+	type fields struct {
+		leftFunc  func() node
+		rightFunc func() node
+	}
+	type args struct {
+		r request.Wrapper
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   bool
+	}{
+		{
+			name: "both nodes true, true returned",
+			fields: fields{
+				leftFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(true)
+
+					return n
+				},
+				rightFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(true)
+
+					return n
+				},
+			},
+			want: true,
+		},
+		{
+			name: "one of nodes false, false returned",
+			fields: fields{
+				leftFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(true)
+
+					return n
+				},
+				rightFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(false)
+
+					return n
+				},
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var left, right node
+			if tt.fields.leftFunc != nil {
+				left = tt.fields.leftFunc()
+			}
+			if tt.fields.rightFunc != nil {
+				right = tt.fields.rightFunc()
+			}
+
+			a := and{
+				left:  left,
+				right: right,
+			}
+			if got := a.Eval(tt.args.r); got != tt.want {
+				t.Errorf("Eval() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_or_Eval(t *testing.T) {
+	type fields struct {
+		leftFunc  func() node
+		rightFunc func() node
+	}
+	type args struct {
+		r request.Wrapper
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   bool
+	}{
+		{
+			name: "first node true, returns true",
+			fields: fields{
+				leftFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(true)
+
+					return n
+				},
+			},
+			want: true,
+		},
+		{
+			name: "both nodes false, returns false",
+			fields: fields{
+				leftFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(false)
+
+					return n
+				},
+				rightFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(false)
+
+					return n
+				},
+			},
+			want: false,
+		},
+		{
+			name: "first node false, second true, returns true",
+			fields: fields{
+				leftFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(false)
+
+					return n
+				},
+				rightFunc: func() node {
+					n := NewMocknode(t)
+
+					n.EXPECT().Eval(mock.Anything).Return(true)
+
+					return n
+				},
+			},
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var left, right node
+			if tt.fields.leftFunc != nil {
+				left = tt.fields.leftFunc()
+			}
+			if tt.fields.rightFunc != nil {
+				right = tt.fields.rightFunc()
+			}
+
+			o := or{
+				left:  left,
+				right: right,
+			}
+			if got := o.Eval(tt.args.r); got != tt.want {
+				t.Errorf("Eval() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/rule/predicate.go

@@ -1,8 +1,6 @@
 package rule
 
 import (
-	"fmt"
-	"io"
 	"waffle/internal/request"
 )
 
@@ -56,24 +54,24 @@ type predicateBuilder struct {
 var _ Builder = (*predicateBuilder)(nil)
 
 func (p *predicateBuilder) Build(name, variable, expression string) (*Predicate, error) {
-	tree := and{
-		left: gt{
-			valueFunc: func(r request.Wrapper) (int, error) {
-				bytes, err := io.ReadAll(r.Request.Body)
-				if err != nil {
-					return 0, fmt.Errorf("cannot read bytes: %w", err)
-				}
-
-				return len(bytes), nil
-			},
-			check: 0,
-		},
-		right: gt{
-			valueFunc: func(r request.Wrapper) (int, error) {
-				return len(r.Request.Header), nil
-			},
-			check: 0,
-		},
-	}
+	//tree := and{
+	//	left: gt{
+	//		valueFunc: func(r request.Wrapper) (int, error) {
+	//			bytes, err := io.ReadAll(r.Request.Body)
+	//			if err != nil {
+	//				return 0, fmt.Errorf("cannot read bytes: %w", err)
+	//			}
+	//
+	//			return len(bytes), nil
+	//		},
+	//		check: 0,
+	//	},
+	//	right: gt{
+	//		valueFunc: func(r request.Wrapper) (int, error) {
+	//			return len(r.Request.Header), nil
+	//		},
+	//		check: 0,
+	//	},
+	//}
 	return nil, nil
 }