Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

6.0 KB
Raw Blame
package querybuilder

import (
	"encoding/json"
	"fmt"
	"math"
	"testing"

	"github.com/stretchr/testify/assert"
)

type customStringer struct {
	value string
}

func (c customStringer) String() string {
	return c.value
}

type customInt int64
type customFloat float64
type customUint uint64

func TestFormatValueForContains(t *testing.T) {
	tests := []struct {
		name     string
		input    any
		expected string
	}{
		{
			name:     "nil value",
			input:    nil,
			expected: "",
		},
		{
			name:     "string value",
			input:    "hello world",
			expected: "hello world",
		},
		{
			name:     "empty string",
			input:    "",
			expected: "",
		},
		{
			name:     "string with special characters",
			input:    "test@#$%^&*()_+-=",
			expected: "test@#$%^&*()_+-=",
		},
		{
			name:     "byte slice",
			input:    []byte("byte slice test"),
			expected: "byte slice test",
		},
		{
			name:     "empty byte slice",
			input:    []byte{},
			expected: "",
		},
		{
			name:     "json.Number integer",
			input:    json.Number("521509198310"),
			expected: "521509198310",
		},
		{
			name:     "json.Number float",
			input:    json.Number("3.14159"),
			expected: "3.14159",
		},
		{
			name:     "json.Number scientific notation",
			input:    json.Number("1.23e+10"),
			expected: "1.23e+10",
		},
		{
			name:     "float64 whole number",
			input:    float64(42),
			expected: "42",
		},
		{
			name:     "float64 decimal",
			input:    float64(3.14159),
			expected: "3.14159",
		},
		{
			name:     "float64 large whole number",
			input:    float64(521509198310),
			expected: "521509198310",
		},
		{
			name:     "float64 at positive threshold",
			input:    float64(1e15),
			expected: "1000000000000000",
		},
		{
			name:     "float64 above positive threshold",
			input:    float64(1e16),
			expected: "10000000000000000",
		},
		{
			name:     "float64 at negative threshold",
			input:    float64(-1e15),
			expected: "-1000000000000000",
		},
		{
			name:     "float64 negative decimal",
			input:    float64(-123.456),
			expected: "-123.456",
		},
		{
			name:     "float64 zero",
			input:    float64(0),
			expected: "0",
		},
		{
			name:     "float32 whole number",
			input:    float32(42),
			expected: "42",
		},
		{
			name:     "float32 decimal",
			input:    float32(3.14),
			expected: "3.14",
		},
		{
			name:     "int",
			input:    int(123),
			expected: "123",
		},
		{
			name:     "int negative",
			input:    int(-456),
			expected: "-456",
		},
		{
			name:     "int8 max",
			input:    int8(127),
			expected: "127",
		},
		{
			name:     "int8 min",
			input:    int8(-128),
			expected: "-128",
		},
		{
			name:     "int16",
			input:    int16(32767),
			expected: "32767",
		},
		{
			name:     "int32",
			input:    int32(2147483647),
			expected: "2147483647",
		},
		{
			name:     "int64",
			input:    int64(9223372036854775807),
			expected: "9223372036854775807",
		},
		{
			name:     "uint",
			input:    uint(123),
			expected: "123",
		},
		{
			name:     "uint8 max",
			input:    uint8(255),
			expected: "255",
		},
		{
			name:     "uint16",
			input:    uint16(65535),
			expected: "65535",
		},
		{
			name:     "uint32",
			input:    uint32(4294967295),
			expected: "4294967295",
		},
		{
			name:     "uint64 large",
			input:    uint64(18446744073709551615),
			expected: "18446744073709551615",
		},
		{
			name:     "bool true",
			input:    true,
			expected: "true",
		},
		{
			name:     "bool false",
			input:    false,
			expected: "false",
		},
		{
			name:     "custom stringer",
			input:    customStringer{value: "custom string value"},
			expected: "custom string value",
		},
		{
			name:     "custom int type",
			input:    customInt(12345),
			expected: "12345",
		},
		{
			name:     "custom float type whole number",
			input:    customFloat(67890),
			expected: "67890",
		},
		{
			name:     "custom float type decimal",
			input:    customFloat(123.456),
			expected: "123.456",
		},
		{
			name:     "custom uint type",
			input:    customUint(99999),
			expected: "99999",
		},
		{
			name:     "struct fallback",
			input:    struct{ Name string }{Name: "test"},
			expected: "{test}",
		},
		{
			name:     "slice fallback",
			input:    []int{1, 2, 3},
			expected: "[1 2 3]",
		},
		{
			name:     "map fallback",
			input:    map[string]int{"a": 1, "b": 2},
			expected: fmt.Sprintf("%v", map[string]int{"a": 1, "b": 2}),
		},
		{
			name:     "float64 infinity",
			input:    math.Inf(1),
			expected: "+Inf",
		},
		{
			name:     "float64 negative infinity",
			input:    math.Inf(-1),
			expected: "-Inf",
		},
		{
			name:     "float64 NaN",
			input:    math.NaN(),
			expected: "NaN",
		},
		{
			name:     "float64 very small positive",
			input:    float64(0.000000123),
			expected: "0.000000123",
		},
		{
			name:     "float64 very small negative",
			input:    float64(-0.000000123),
			expected: "-0.000000123",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := FormatValueForContains(tt.input)
			assert.Equal(t, tt.expected, result)
		})
	}
}

func TestFormatValueForContains_LargeNumberScientificNotation(t *testing.T) {
	largeNumber := float64(521509198310)
	result := FormatValueForContains(largeNumber)
	assert.Equal(t, "521509198310", result)
	assert.NotEqual(t, "5.2150919831e+11", result)
}

func TestFormatFullTextSearch(t *testing.T) {
	tests := []struct {
		input    string
		expected string
	}{
		// valid regex, unchanged
		{"foo.*bar", "foo.*bar"},
		// invalid regex, escaped
		{"[ERROR-1234]", `\[ERROR-1234\]`},
		// literal with +
		{"C++ Error", `C\+\+ Error`},
		// IP address, valid regex but unsafe chars
		{"10.0.0.1", "10.0.0.1"},
		// java class, '.' will still be regex wildcard
		{"java.lang.NullPointerException", "java.lang.NullPointerException"},
		// a-o  invalid character class range
		{"[LocalLog partition=__cluster_metadata-0,", "\\[LocalLog partition=__cluster_metadata-0,"},
		{"[abcd]", "[abcd]"},
	}
	for _, tt := range tests {
		got := FormatFullTextSearch(tt.input)
		if got != tt.expected {
			t.Errorf("FormatFullTextSearch(%q) = %q, want %q", tt.input, got, tt.expected)
		}
	}
}