ekuiper-new/internal/binder/function/funcs_agg_test.go

// Copyright 2022 EMQ Technologies Co., Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package function

import (
	"fmt"
	"reflect"
	"testing"

	"github.com/lf-edge/ekuiper/internal/conf"
	kctx "github.com/lf-edge/ekuiper/internal/topo/context"
	"github.com/lf-edge/ekuiper/internal/topo/state"
	"github.com/lf-edge/ekuiper/pkg/api"
)

func TestAggExec(t *testing.T) {
	fAvg, ok := builtins["avg"]
	if !ok {
		t.Fatal("builtin not found")
	}
	fMax, ok := builtins["max"]
	if !ok {
		t.Fatal("builtin not found")
	}
	fMin, ok := builtins["min"]
	if !ok {
		t.Fatal("builtin not found")
	}
	fStddev, ok := builtins["stddev"]
	if !ok {
		t.Fatal("builtin not found")
	}
	fStddevs, ok := builtins["stddevs"]
	if !ok {
		t.Fatal("builtin not found")
	}
	fVar, ok := builtins["var"]
	if !ok {
		t.Fatal("builtin not found")
	}
	fVars, ok := builtins["vars"]
	if !ok {
		t.Fatal("builtin not found")
	}
	contextLogger := conf.Log.WithField("rule", "testExec")
	ctx := kctx.WithValue(kctx.Background(), kctx.LoggerKey, contextLogger)
	tempStore, _ := state.CreateStore("mockRule0", api.AtMostOnce)
	fctx := kctx.NewDefaultFuncContext(ctx.WithMeta("mockRule0", "test", tempStore), 2)
	var tests = []struct {
		args    []interface{}
		avg     interface{}
		max     interface{}
		min     interface{}
		stddev  interface{}
		stddevs interface{}
		var1    interface{}
		vars    interface{}
	}{
		{ // 0
			args: []interface{}{
				[]interface{}{
					"foo",
					"bar",
					"self",
				},
			},
			avg:     fmt.Errorf("run avg function error: found invalid arg string(foo)"),
			max:     "self",
			min:     "bar",
			stddev:  fmt.Errorf("requires float64 slice but found []interface {}([foo bar self])"),
			stddevs: fmt.Errorf("requires float64 slice but found []interface {}([foo bar self])"),
			var1:    fmt.Errorf("requires float64 slice but found []interface {}([foo bar self])"),
			vars:    fmt.Errorf("requires float64 slice but found []interface {}([foo bar self])"),
		}, { // 1
			args: []interface{}{
				[]interface{}{
					int64(100),
					int64(150),
					int64(200),
				},
			},
			avg:     int64(150),
			max:     int64(200),
			min:     int64(100),
			stddev:  40.824829046386306,
			stddevs: float64(50),
			var1:    1666.6666666666667,
			vars:    float64(2500),
		}, { // 2
			args: []interface{}{
				[]interface{}{
					float64(100),
					float64(150),
					float64(200),
				},
			},
			avg:     float64(150),
			max:     float64(200),
			min:     float64(100),
			stddev:  40.824829046386306,
			stddevs: float64(50),
			var1:    1666.6666666666667,
			vars:    float64(2500),
		}, { // 3
			args: []interface{}{
				[]interface{}{
					100, 150, 200,
				},
			},
			avg:     int64(150),
			max:     int64(200),
			min:     int64(100),
			stddev:  40.824829046386306,
			stddevs: float64(50),
			var1:    1666.6666666666667,
			vars:    float64(2500),
		}, { // 4
			args: []interface{}{
				[]interface{}{},
			},
			avg:     nil,
			max:     nil,
			min:     nil,
			stddev:  nil,
			stddevs: nil,
			var1:    nil,
			vars:    nil,
		},
	}
	for i, tt := range tests {
		rAvg, _ := fAvg.exec(fctx, tt.args)
		if !reflect.DeepEqual(rAvg, tt.avg) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rAvg, tt.avg)
		}
		rMax, _ := fMax.exec(fctx, tt.args)
		if !reflect.DeepEqual(rMax, tt.max) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rMax, tt.max)
		}
		rMin, _ := fMin.exec(fctx, tt.args)
		if !reflect.DeepEqual(rMin, tt.min) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rMin, tt.min)
		}
		rStddev, _ := fStddev.exec(fctx, tt.args)
		if !reflect.DeepEqual(rStddev, tt.stddev) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rStddev, tt.stddev)
		}
		rStddevs, _ := fStddevs.exec(fctx, tt.args)
		if !reflect.DeepEqual(rStddevs, tt.stddevs) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rStddevs, tt.stddevs)
		}
		rVar, _ := fVar.exec(fctx, tt.args)
		if !reflect.DeepEqual(rVar, tt.var1) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rVar, tt.var1)
		}
		rVars, _ := fVars.exec(fctx, tt.args)
		if !reflect.DeepEqual(rVars, tt.vars) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rVars, tt.vars)
		}
	}
}

func TestPercentileExec(t *testing.T) {
	pCont, ok := builtins["percentile_cont"]
	if !ok {
		t.Fatal("builtin not found")
	}
	pDisc, ok := builtins["percentile_disc"]
	if !ok {
		t.Fatal("builtin not found")
	}
	contextLogger := conf.Log.WithField("rule", "testExec")
	ctx := kctx.WithValue(kctx.Background(), kctx.LoggerKey, contextLogger)
	tempStore, _ := state.CreateStore("mockRule0", api.AtMostOnce)
	fctx := kctx.NewDefaultFuncContext(ctx.WithMeta("mockRule0", "test", tempStore), 2)
	var tests = []struct {
		args  []interface{}
		pCont interface{}
		pDisc interface{}
	}{
		{ // 0
			args: []interface{}{
				[]interface{}{
					"foo",
					"bar",
					"self",
				},
				[]interface{}{0.25, 0.25, 0.25},
			},
			pCont: fmt.Errorf("requires float64 slice but found []interface {}([foo bar self])"),
			pDisc: fmt.Errorf("requires float64 slice but found []interface {}([foo bar self])"),
		}, { // 1
			args: []interface{}{
				[]interface{}{
					int64(100),
					int64(150),
					int64(200),
				},
			},
			pCont: fmt.Errorf("Expect 2 arguments but found 1."),
			pDisc: fmt.Errorf("Expect 2 arguments but found 1."),
		}, { // 2
			args: []interface{}{
				[]interface{}{
					int64(100),
					int64(150),
					int64(200),
				},
				[]interface{}{0.5, 0.5, 0.5},
			},
			pCont: float64(125),
			pDisc: float64(150),
		}, { // 3
			args: []interface{}{
				[]interface{}{
					float64(100),
					float64(150),
					float64(200),
				},
				[]interface{}{0.5, 0.5, 0.5},
			},
			pCont: float64(125),
			pDisc: float64(150),
		}, { // 4
			args: []interface{}{
				[]interface{}{
					100, 150, 200,
				},
				[]interface{}{0.5, 0.5, 0.5},
			},
			pCont: float64(125),
			pDisc: float64(150),
		}, { //5
			args: []interface{}{[]interface{}{},
				[]interface{}{}},
			pCont: nil,
			pDisc: nil,
		},
	}
	for i, tt := range tests {
		rCont, _ := pCont.exec(fctx, tt.args)
		if !reflect.DeepEqual(rCont, tt.pCont) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rCont, tt.pCont)
		}
		rDisc, _ := pDisc.exec(fctx, tt.args)
		if !reflect.DeepEqual(rDisc, tt.pDisc) {
			t.Errorf("%d result mismatch,\ngot:\t%v \nwant:\t%v", i, rDisc, tt.pCont)
		}
	}
}