types.Make{Int,String}: Variadic validator functions

The MakeString function got another variadic parameter, allowing
multiple validators against the newly created String. As one example,
the newly introduced StringMustNotBeEmpty function can be used,
mimicking Icinga Notifications' ToDBString behavior.

To replace Icinga Notifications' ToDBInt utility function, a similar
MakeInt function and IntMustNotBeZero was introduced.

Inspired by:
- ToDBInt, Icinga/icinga-notifications@f0b39f0
- ToDBString, Icinga/icinga-notifications@8183344

Author: oxzi

types/int.go

@@ -14,6 +14,29 @@ type Int struct {
 	sql.NullInt64
 }
 
+// IntMustNotBeZero validates that an Int is valid and not the numerical value zero.
+func IntMustNotBeZero(i Int) bool {
+	return i.Valid && i.Int64 != 0
+}
+
+// MakeInt constructs a new Int.
+//
+// Multiple validators functions can be given, each validating the generated Int. If any returns false, a NULL
+// String is returned instead. For example, there is IntMustNotBeZero.
+func MakeInt(in int64, validators ...func(Int) bool) Int {
+	i := Int{sql.NullInt64{
+		Int64: in,
+		Valid: true,
+	}}
+
+	for _, validator := range validators {
+		if !validator(i) {
+			return Int{sql.NullInt64{Valid: false}}
+		}
+	}
+	return i
+}
+
 // MarshalJSON implements the json.Marshaler interface.
 // Supports JSON null.
 func (i Int) MarshalJSON() ([]byte, error) {

types/int_test.go

@@ -6,6 +6,49 @@ import (
 	"testing"
 )
 
+func TestMakeInt(t *testing.T) {
+	subtests := []struct {
+		name       string
+		input      int64
+		validators []func(Int) bool
+		output     sql.NullInt64
+	}{
+		{
+			name:   "zero",
+			input:  0,
+			output: sql.NullInt64{Int64: 0, Valid: true},
+		},
+		{
+			name:   "positive",
+			input:  1,
+			output: sql.NullInt64{Int64: 1, Valid: true},
+		},
+		{
+			name:   "negative",
+			input:  -1,
+			output: sql.NullInt64{Int64: -1, Valid: true},
+		},
+		{
+			name:       "zero-validator-not-zero",
+			input:      0,
+			validators: []func(Int) bool{IntMustNotBeZero},
+			output:     sql.NullInt64{Valid: false},
+		},
+		{
+			name:       "positive-validator-not-zero",
+			input:      1,
+			validators: []func(Int) bool{IntMustNotBeZero},
+			output:     sql.NullInt64{Int64: 1, Valid: true},
+		},
+	}
+
+	for _, st := range subtests {
+		t.Run(st.name, func(t *testing.T) {
+			require.Equal(t, Int{NullInt64: st.output}, MakeInt(st.input, st.validators...))
+		})
+	}
+}
+
 func TestInt_MarshalJSON(t *testing.T) {
 	subtests := []struct {
 		name   string

types/string.go

@@ -14,12 +14,27 @@ type String struct {
 	sql.NullString
 }
 
-// MakeString constructs a new non-NULL String from s.
-func MakeString(s string) String {
-	return String{sql.NullString{
-		String: s,
+// StringMustNotBeEmpty validates that a String is valid and not empty.
+func StringMustNotBeEmpty(s String) bool {
+	return s.Valid && s.String != ""
+}
+
+// MakeString constructs a new String.
+//
+// Multiple validators functions can be given, each validating the generated String. If any returns false, a NULL
+// String is returned instead. For example, there is StringMustNotBeEmpty.
+func MakeString(in string, validators ...func(String) bool) String {
+	s := String{sql.NullString{
+		String: in,
 		Valid:  true,
 	}}
+
+	for _, validator := range validators {
+		if !validator(s) {
+			return String{sql.NullString{Valid: false}}
+		}
+	}
+	return s
 }
 
 // MarshalJSON implements the json.Marshaler interface.

types/string_test.go

@@ -9,18 +9,48 @@ import (
 
 func TestMakeString(t *testing.T) {
 	subtests := []struct {
-		name string
-		io   string
+		name       string
+		input      string
+		validators []func(String) bool
+		output     sql.NullString
 	}{
-		{"empty", ""},
-		{"nul", "\x00"},
-		{"space", " "},
-		{"multiple", "abc"},
+		{
+			name:   "empty",
+			input:  "",
+			output: sql.NullString{String: "", Valid: true},
+		},
+		{
+			name:   "nul",
+			input:  "\x00",
+			output: sql.NullString{String: "\x00", Valid: true},
+		},
+		{
+			name:   "space",
+			input:  " ",
+			output: sql.NullString{String: " ", Valid: true},
+		},
+		{
+			name:   "valid-text",
+			input:  "abc",
+			output: sql.NullString{String: "abc", Valid: true},
+		},
+		{
+			name:       "empty-validator-not-empty",
+			input:      "",
+			validators: []func(String) bool{StringMustNotBeEmpty},
+			output:     sql.NullString{Valid: false},
+		},
+		{
+			name:       "valid-text-validator-not-empty",
+			input:      "abc",
+			validators: []func(String) bool{StringMustNotBeEmpty},
+			output:     sql.NullString{String: "abc", Valid: true},
+		},
 	}
 
 	for _, st := range subtests {
 		t.Run(st.name, func(t *testing.T) {
-			require.Equal(t, String{NullString: sql.NullString{String: st.io, Valid: true}}, MakeString(st.io))
+			require.Equal(t, String{NullString: st.output}, MakeString(st.input, st.validators...))
 		})
 	}
 }