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.

12.0 KB
Raw Blame
package alertmanagertemplate

import (
	"testing"
	"time"

	"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
	"github.com/prometheus/alertmanager/template"
	"github.com/stretchr/testify/require"
)

func TestExtractFieldMappings(t *testing.T) {
	// Flat struct: mapstructure-tagged leaves only. Slices and interfaces are
	// dropped; maps (labels/annotations analogues) are kept as top-level leaves.
	type Flat struct {
		Name       string            `mapstructure:"name"`
		Status     string            `mapstructure:"status"`
		UserCount  int               `mapstructure:"user_count"`
		IsActive   bool              `mapstructure:"is_active"`
		CreatedAt  time.Time         `mapstructure:"created_at"`
		Extra      map[string]string `mapstructure:"extra"`
		Items      []string          `mapstructure:"items"` // slice skipped
		unexported string            //nolint:unused // unexported skipped
		NoTag      string            // no mapstructure tag skipped
		SkippedTag string            `mapstructure:"-"` // explicit skip
	}

	// Nested struct: sub-struct paths are flattened into dotted mappings; the
	// parent path itself is also emitted so templates can bind `$alert := .alert`.
	type Inner struct {
		Value string `mapstructure:"value"`
		Op    string `mapstructure:"op"`
	}
	type Outer struct {
		Alert struct {
			Status   string `mapstructure:"status"`
			IsFiring bool   `mapstructure:"is_firing"`
		} `mapstructure:"alert"`
		Rule struct {
			Name      string `mapstructure:"name"`
			Threshold Inner  `mapstructure:"threshold"`
		} `mapstructure:"rule"`
	}

	testCases := []struct {
		name     string
		data     any
		expected []fieldPath
	}{
		{
			name: "flat struct surfaces only mapstructure-tagged scalars",
			data: Flat{},
			expected: []fieldPath{
				"name", "status", "user_count", "is_active", "created_at", "extra",
			},
		},
		{
			name: "nested struct emits parent and dotted leaf paths",
			data: Outer{},
			expected: []fieldPath{
				"alert",
				"alert.status",
				"alert.is_firing",
				"rule",
				"rule.name",
				"rule.threshold",
				"rule.threshold.value",
				"rule.threshold.op",
			},
		},
		{
			name:     "nil data",
			data:     nil,
			expected: nil,
		},
		{
			name:     "non-struct type",
			data:     "string",
			expected: nil,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result := extractFieldMappings(tc.data)
			require.Equal(t, tc.expected, result)
		})
	}
}

func TestBuildVariableDefinitions(t *testing.T) {
	testCases := []struct {
		name          string
		tmpl          string
		data          any
		expectedVars  []string // substrings that must appear in result
		forbiddenVars []string // substrings that must NOT appear (dotted identifiers)
		expectError   bool
	}{
		{
			name: "empty template still emits struct bindings for title data",
			tmpl: "",
			data: &alertmanagertypes.NotificationTemplateData{Alert: alertmanagertypes.NotificationAlert{Receiver: "slack"}},
			expectedVars: []string{
				"{{ $alert := .alert }}",
				"{{ $rule := .rule }}",
			},
			// Dotted leaves are NOT emitted as preamble bindings — they're
			// reached via {{ index . "alert" "status" }} at expansion time.
			forbiddenVars: []string{
				"$alert.status",
				"$rule.threshold.value",
			},
		},
		{
			name: "mix of known and unknown vars in alert body",
			tmpl: "$rule.name fired: $custom_label",
			data: &alertmanagertypes.AlertData{Rule: alertmanagertypes.RuleInfo{Name: "test"}, Alert: alertmanagertypes.AlertInfo{Status: "firing"}},
			expectedVars: []string{
				"{{ $alert := .alert }}",
				"{{ $rule := .rule }}",
				`{{ $custom_label := "<no value>" }}`,
			},
		},
		{
			name: "known dotted variables do not get flagged as unknown",
			tmpl: "$alert.is_firing and $rule.threshold.value",
			data: &alertmanagertypes.AlertData{},
			// $alert and $rule (first segments) are in mappings, so no unknown
			// stubs; the dotted leaves are resolved by WrapDollarVariables.
			expectedVars: []string{
				"{{ $alert := .alert }}",
				"{{ $rule := .rule }}",
			},
			forbiddenVars: []string{
				`"<no value>"`,
			},
		},
		{
			// Label-derived $-refs aren't stubbed as unknown; their first
			// segment is marked known so {{ $severity := ... }} stubs don't
			// appear in the preamble. Resolution happens at expansion via the
			// root-level flattening performed in buildDataMap.
			name: "label first-segments suppress unknown-var stubs",
			tmpl: "$severity for $service $cloud.region.instance",
			data: &alertmanagertypes.NotificationTemplateData{Labels: template.KV{
				"severity":              "critical",
				"service":               "test",
				"cloud.region.instance": "ap-south-1",
			}},
			forbiddenVars: []string{
				`{{ $severity := "<no value>" }}`,
				`{{ $service := "<no value>" }}`,
				`{{ $cloud := "<no value>" }}`,
			},
		},
		{
			name: "same rule holds for AlertData labels",
			tmpl: "$severity $service",
			data: &alertmanagertypes.AlertData{Labels: template.KV{
				"severity": "critical",
				"service":  "test",
			}},
			forbiddenVars: []string{
				`{{ $severity := "<no value>" }}`,
				`{{ $service := "<no value>" }}`,
			},
		},
		{
			name:        "invalid template syntax returns error",
			tmpl:        "{{invalid",
			data:        &alertmanagertypes.NotificationTemplateData{},
			expectError: true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result, _, err := buildPreamble(tc.tmpl, tc.data)
			if tc.expectError {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)
			for _, expected := range tc.expectedVars {
				require.Contains(t, result, expected, "expected preamble substring missing")
			}
			for _, forbidden := range tc.forbiddenVars {
				require.NotContains(t, result, forbidden, "unexpected preamble substring present")
			}
		})
	}
}

func TestPreProcessTemplateAndData(t *testing.T) {
	testCases := []struct {
		name                     string
		tmpl                     string
		data                     any
		expectedTemplateContains []string
		expectedData             map[string]any
		expectedUnknownVars      map[string]bool
		expectError              bool
	}{
		{
			name: "title template: struct-root walks and flat dotted label keys",
			tmpl: "[$alert.status] $rule.name (ID: $rule.id) firing=$alert.total_firing severity=$severity method=$http.request.method",
			data: &alertmanagertypes.NotificationTemplateData{
				Alert: alertmanagertypes.NotificationAlert{
					Receiver:    "pagerduty",
					Status:      "firing",
					TotalFiring: 3,
				},
				Rule: alertmanagertypes.RuleInfo{
					Name: "HighMemory",
					ID:   "rule-123",
				},
				Labels: template.KV{
					"severity":            "critical",
					"http.request.method": "GET",
				},
			},
			expectedTemplateContains: []string{
				"{{$alert := .alert}}",
				"{{$rule := .rule}}",
				`[{{ index . "alert" "status" }}] {{ index . "rule" "name" }} (ID: {{ index . "rule" "id" }})`,
				`firing={{ index . "alert" "total_firing" }} severity={{ .severity }}`,
				`method={{ index . "http.request.method" }}`,
			},
			expectedData: map[string]any{
				"alert": map[string]any{
					"receiver":       "pagerduty",
					"status":         "firing",
					"total_firing":   3,
					"total_resolved": 0,
				},
				"severity":            "critical",
				"http.request.method": "GET",
			},
			expectedUnknownVars: map[string]bool{},
		},
		{
			name: "body template with nested threshold access and per-alert annotation",
			tmpl: "$rule.name: value $alert.value $rule.threshold.op $rule.threshold.value ($alert.status) desc=$description",
			data: &alertmanagertypes.AlertData{
				Alert: alertmanagertypes.AlertInfo{
					Status:   "firing",
					Value:    "85%",
					IsFiring: true,
				},
				Rule: alertmanagertypes.RuleInfo{
					Name:      "DiskFull",
					ID:        "disk-001",
					Severity:  "warning",
					Threshold: alertmanagertypes.Threshold{Value: "80%", Op: ">"},
				},
				Annotations: template.KV{
					"description": "Disk full and cannot be written to",
				},
			},
			expectedTemplateContains: []string{
				"{{$alert := .alert}}",
				"{{$rule := .rule}}",
				// "description" is an annotation flattened to root; the preamble
				// now binds it off the root rather than via .annotations lookup.
				"{{$description := .description}}",
				`{{ index . "rule" "name" }}: value {{ index . "alert" "value" }} {{ index . "rule" "threshold" "op" }} {{ index . "rule" "threshold" "value" }}`,
			},
			expectedData: map[string]any{
				"description": "Disk full and cannot be written to",
			},
			expectedUnknownVars: map[string]bool{},
		},
		{
			// Struct roots reserve their first-segment namespace: a label
			// whose key starts with "alert." is shadowed by the Alert sub-map,
			// and must be accessed via the explicit $labels.* prefix.
			name: "label colliding with struct root is accessed via $labels.*",
			tmpl: "$alert.status via $labels.alert.custom",
			data: &alertmanagertypes.NotificationTemplateData{
				Alert:  alertmanagertypes.NotificationAlert{Status: "firing"},
				Labels: template.KV{"alert.custom": "x"},
			},
			expectedTemplateContains: []string{
				`{{ index . "alert" "status" }}`,
				`{{ index .labels "alert.custom" }}`,
			},
		},
		{
			// Same shadowing rule applies symmetrically to annotations.
			name: "annotation colliding with struct root is accessed via $annotations.*",
			tmpl: "$alert.status via $annotations.alert.meta",
			data: &alertmanagertypes.NotificationTemplateData{
				Alert:       alertmanagertypes.NotificationAlert{Status: "firing"},
				Annotations: template.KV{"alert.meta": "x"},
			},
			expectedTemplateContains: []string{
				`{{ index . "alert" "status" }}`,
				`{{ index .annotations "alert.meta" }}`,
			},
		},
		{
			// When a label and an annotation share a key, the label wins at the
			// root flattening layer. Users who want the annotation must address
			// it explicitly via $annotations.<key>.
			name: "label takes precedence over same-named annotation at root",
			tmpl: "flat=$env labels_only=$labels.env annotations_only=$annotations.env",
			data: &alertmanagertypes.NotificationTemplateData{
				Labels:      template.KV{"env": "prod"},
				Annotations: template.KV{"env": "staging"},
			},
			expectedTemplateContains: []string{
				`flat={{ .env }}`,
				`labels_only={{ index .labels "env" }}`,
				`annotations_only={{ index .annotations "env" }}`,
			},
			expectedData: map[string]any{
				"env": "prod",
			},
		},
		{
			name: "empty template returns flattened data",
			tmpl: "",
			data: &alertmanagertypes.NotificationTemplateData{Alert: alertmanagertypes.NotificationAlert{Receiver: "slack"}},
		},
		{
			name:        "invalid template syntax",
			tmpl:        "{{invalid",
			data:        &alertmanagertypes.NotificationTemplateData{},
			expectError: true,
		},
		{
			name: "unknown dollar var in text renders empty",
			tmpl: "alert $custom_note fired",
			data: &alertmanagertypes.NotificationTemplateData{Rule: alertmanagertypes.RuleInfo{Name: "HighCPU"}},
			expectedTemplateContains: []string{
				`{{$custom_note := "<no value>"}}`,
				"alert {{ .custom_note }} fired",
			},
			expectedUnknownVars: map[string]bool{"custom_note": true},
		},
		{
			name: "unknown dollar var in action block renders empty",
			tmpl: "alert {{ $custom_note }} fired",
			data: &alertmanagertypes.NotificationTemplateData{Rule: alertmanagertypes.RuleInfo{Name: "HighCPU"}},
			expectedTemplateContains: []string{
				`{{$custom_note := "<no value>"}}`,
				`alert {{$custom_note}} fired`,
			},
			expectedUnknownVars: map[string]bool{"custom_note": true},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result, err := preProcessTemplateAndData(tc.tmpl, tc.data)

			if tc.expectError {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)

			if tc.tmpl == "" {
				require.Equal(t, "", result.Template)
				return
			}

			for _, substr := range tc.expectedTemplateContains {
				require.Contains(t, result.Template, substr)
			}
			for k, v := range tc.expectedData {
				require.Equal(t, v, result.Data[k], "data[%q] mismatch", k)
			}
			if tc.expectedUnknownVars != nil {
				require.Equal(t, tc.expectedUnknownVars, result.UnknownVars)
			}
		})
	}
}