Introduce notifications Severity type

Moved from Icinga Notifications with some enhancements made.

Author: yhabteab

go.mod

@@ -33,3 +33,7 @@ require (
 	golang.org/x/sys v0.26.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
+
+tool (
+	golang.org/x/tools/cmd/stringer
+)

notifications/event/severity.go

@@ -0,0 +1,106 @@
+//go:generate go tool stringer -linecomment -type Severity -output severity_string.go
+
+package event
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"fmt"
+)
+
+// Severity represents the severity level of an event in Icinga notifications.
+// It is an integer type with predefined constants for different severity levels.
+type Severity uint8
+
+const (
+	SeverityNone Severity = iota // none
+
+	SeverityOK      // ok
+	SeverityDebug   // debug
+	SeverityInfo    // info
+	SeverityNotice  // notice
+	SeverityWarning // warning
+	SeverityErr     // err
+	SeverityCrit    // crit
+	SeverityAlert   // alert
+	SeverityEmerg   // emerg
+
+	severityMax // internal
+)
+
+// MarshalJSON implements the [json.Marshaler] interface for Severity.
+func (s Severity) MarshalJSON() ([]byte, error) {
+	if s != SeverityNone {
+		return json.Marshal(s.String())
+	} else {
+		return json.Marshal(nil)
+	}
+}
+
+// UnmarshalJSON implements the [json.Unmarshaler] interface for Severity.
+func (s *Severity) UnmarshalJSON(data []byte) error {
+	if string(data) == "null" {
+		*s = SeverityNone
+		return nil
+	}
+
+	var severityStr string
+	if err := json.Unmarshal(data, &severityStr); err != nil {
+		return err
+	}
+
+	severity, err := ParseSeverity(severityStr)
+	if err != nil {
+		return err
+	}
+
+	*s = severity
+	return nil
+}
+
+// Scan implements the [sql.Scanner] interface for Severity.
+// Supports SQL NULL values.
+func (s *Severity) Scan(src any) error {
+	if src == nil {
+		*s = SeverityNone
+		return nil
+	}
+
+	var severityStr string
+	switch val := src.(type) {
+	case string:
+		severityStr = val
+	case []byte:
+		severityStr = string(val)
+	default:
+		return fmt.Errorf("cannot scan severity from type %T", src)
+	}
+
+	severity, err := ParseSeverity(severityStr)
+	if err != nil {
+		return err
+	}
+
+	*s = severity
+	return nil
+}
+
+// Value implements the [driver.Valuer] interface for Severity.
+func (s Severity) Value() (driver.Value, error) {
+	if s != SeverityNone {
+		return s.String(), nil
+	}
+	return nil, nil // Return nil for SeverityNone or invalid values
+}
+
+// ParseSeverity parses a string representation of a severity level and returns the corresponding Severity value.
+// If the string does not match any known severity, it returns an error indicating the unknown severity.
+func ParseSeverity(name string) (Severity, error) {
+	for s := SeverityNone + 1; s < severityMax; s++ {
+		if s.String() == name {
+			return s, nil
+		}
+	}
+
+	return SeverityNone, fmt.Errorf("unknown severity %q", name)
+}

notifications/event/severity_string.go

@@ -0,0 +1,126 @@
+package event
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestSeverity(t *testing.T) {
+	t.Parallel()
+
+	t.Run("MarshalJson", func(t *testing.T) {
+		t.Parallel()
+
+		tests := []struct {
+			severity Severity
+			expected string
+		}{
+			{SeverityNone, "null"},
+			{SeverityOK, `"ok"`},
+			{SeverityDebug, `"debug"`},
+			{SeverityInfo, `"info"`},
+			{SeverityNotice, `"notice"`},
+			{SeverityWarning, `"warning"`},
+			{SeverityErr, `"err"`},
+			{SeverityCrit, `"crit"`},
+			{SeverityAlert, `"alert"`},
+			{SeverityEmerg, `"emerg"`},
+		}
+
+		for _, test := range tests {
+			data, err := json.Marshal(test.severity)
+			require.NoError(t, err)
+			assert.Equal(t, test.expected, string(data))
+		}
+	})
+
+	t.Run("UnmarshalJson", func(t *testing.T) {
+		t.Parallel()
+
+		tests := []struct {
+			input    string
+			expected Severity
+			wantErr  bool
+		}{
+			{`null`, SeverityNone, false},
+			{`"ok"`, SeverityOK, false},
+			{`"debug"`, SeverityDebug, false},
+			{`"info"`, SeverityInfo, false},
+			{`"notice"`, SeverityNotice, false},
+			{`"warning"`, SeverityWarning, false},
+			{`"err"`, SeverityErr, false},
+			{`"crit"`, SeverityCrit, false},
+			{`"alert"`, SeverityAlert, false},
+			{`"emerg"`, SeverityEmerg, false},
+			{`"invalid"`, SeverityNone, true}, // Invalid severity
+		}
+
+		for _, test := range tests {
+			var severity Severity
+			err := json.Unmarshal([]byte(test.input), &severity)
+			assert.Equalf(t, test.wantErr, err != nil, "expected error: %v, got: %v", test.wantErr, err)
+			assert.Equal(t, test.expected, severity)
+		}
+	})
+
+	t.Run("Scan", func(t *testing.T) {
+		t.Parallel()
+
+		tests := []struct {
+			input    any
+			expected Severity
+			wantErr  bool
+		}{
+			{nil, SeverityNone, false},
+			{"ok", SeverityOK, false},
+			{"debug", SeverityDebug, false},
+			{"info", SeverityInfo, false},
+			{"notice", SeverityNotice, false},
+			{"warning", SeverityWarning, false},
+			{"err", SeverityErr, false},
+			{"crit", SeverityCrit, false},
+			{"alert", SeverityAlert, false},
+			{"emerg", SeverityEmerg, false},
+			{123, SeverityNone, true},               // Invalid type
+			{[]byte("invalid"), SeverityNone, true}, // Invalid severity
+		}
+
+		for _, test := range tests {
+			var severity Severity
+			if err := severity.Scan(test.input); test.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, test.expected, severity)
+			}
+		}
+	})
+
+	t.Run("Value", func(t *testing.T) {
+		t.Parallel()
+
+		tests := []struct {
+			severity Severity
+			expected any
+		}{
+			{SeverityNone, nil},
+			{SeverityOK, "ok"},
+			{SeverityDebug, "debug"},
+			{SeverityInfo, "info"},
+			{SeverityNotice, "notice"},
+			{SeverityWarning, "warning"},
+			{SeverityErr, "err"},
+			{SeverityCrit, "crit"},
+			{SeverityAlert, "alert"},
+			{SeverityEmerg, "emerg"},
+		}
+
+		for _, test := range tests {
+			value, err := test.severity.Value()
+			require.NoError(t, err)
+			assert.Equal(t, test.expected, value)
+		}
+	})
+}