opentelemetry-collector-contrib/pkg/ottl/ottlfuncs/internal/funcutil/lambda_test.go at 3daae767494936191fae0b0bbfc3fbc6e51b0ab4 · open-telemetry/opentelemetry-collector-contrib · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

package funcutil

import (
	"context"
	"errors"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.opentelemetry.io/collector/pdata/pcommon"

	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/ottl"
)

func activateTestLambda(t *testing.T, expr *ottl.LambdaExpression[any], arity int) *ottl.LambdaActivation[any] {
	t.Helper()
	require.NoError(t, expr.ValidateArity(arity))
	lb, err := expr.Activate(t.Context())
	require.NoError(t, err)
	t.Cleanup(lb.Close)
	return lb
}

func TestEvaluateBiPredicate(t *testing.T) {
	expr := ottl.NewTestingLambdaExpression[any]([]string{"k", "v"}, func(_ context.Context, _ any, resolveBinding func(string) any) (any, error) {
		k := resolveBinding("k")
		v := resolveBinding("v")
		return k.(string) == "match" && v.(int64) > 0, nil
	})
	lb := activateTestLambda(t, expr, 2)

	got, err := EvaluateBiPredicate[any](nil, lb, "match", int64(1))
	require.NoError(t, err)
	assert.True(t, got)

	got, err = EvaluateBiPredicate[any](nil, lb, "other", int64(1))
	require.NoError(t, err)
	assert.False(t, got)
}

func TestEvaluateBiPredicate_normalizesPcommonValue(t *testing.T) {
	expr := ottl.NewTestingLambdaExpression[any]([]string{"k", "v"}, func(_ context.Context, _ any, resolveBinding func(string) any) (any, error) {
		k := resolveBinding("k")
		v := resolveBinding("v")
		return k.(string) == "key" && v.(int64) == 7, nil
	})
	lb := activateTestLambda(t, expr, 2)

	got, err := EvaluateBiPredicate[any](nil, lb, pcommon.NewValueStr("key"), pcommon.NewValueInt(7))
	require.NoError(t, err)
	assert.True(t, got)
}

func TestEvaluateBiFunction(t *testing.T) {
	expr := ottl.NewTestingLambdaExpression[any]([]string{"k", "v"}, func(_ context.Context, _ any, resolveBinding func(string) any) (any, error) {
		k := resolveBinding("k")
		v := resolveBinding("v")
		return k.(string) + v.(string), nil
	})
	lb := activateTestLambda(t, expr, 2)

	got, err := EvaluateBiFunction[any, string](nil, lb, "hello", " world")
	require.NoError(t, err)
	assert.Equal(t, "hello world", got)
}

func TestEvaluateBiFunction_unwrapsPcommonValueResult(t *testing.T) {
	expr := ottl.NewTestingLambdaExpression[any]([]string{"_", "_"}, func(_ context.Context, _ any, _ func(string) any) (any, error) {
		return pcommon.NewValueStr("from-value"), nil
	})
	lb := activateTestLambda(t, expr, 2)

	got, err := EvaluateBiFunction[any, string](nil, lb, nil, nil)
	require.NoError(t, err)
	assert.Equal(t, "from-value", got)
}

func TestEvaluateLambdaActivation_directType(t *testing.T) {
	expr := ottl.NewTestingLambdaExpression[any]([]string{"v"}, func(_ context.Context, _ any, _ func(string) any) (any, error) {
		return int64(42), nil
	})
	lb := activateTestLambda(t, expr, 1)
	require.NoError(t, lb.SetArg(0, int64(0)))

	got, err := EvaluateLambdaActivation[any, int64](nil, lb)
	require.NoError(t, err)
	assert.Equal(t, int64(42), got)
}

func TestEvaluateLambdaActivation_evalError(t *testing.T) {
	expr := ottl.NewTestingLambdaExpression[any]([]string{"a"}, func(_ context.Context, _ any, _ func(string) any) (any, error) {
		return nil, errors.New("eval failed")
	})
	lb := activateTestLambda(t, expr, 1)
	require.NoError(t, lb.SetArg(0, "x"))

	_, err := EvaluateLambdaActivation[any, bool](nil, lb)
	require.Error(t, err)
	assert.ErrorContains(t, err, "eval failed")
}

func TestEvaluateLambdaActivation_typeError(t *testing.T) {
	expr := ottl.NewTestingLambdaExpression[any]([]string{"_"}, func(_ context.Context, _ any, _ func(string) any) (any, error) {
		return 123, nil
	})
	lb := activateTestLambda(t, expr, 1)
	require.NoError(t, lb.SetArg(0, nil))

	_, err := EvaluateLambdaActivation[any, string](nil, lb)
	require.Error(t, err)
	assert.ErrorContains(t, err, "lambda expression must return a value of type string")
}