From 40c3c29af290c5ab7be359a03d01c832c0aa6d4f Mon Sep 17 00:00:00 2001
From: Noah Hilverling <noah.hilverling@icinga.com>
Date: Fri, 12 Nov 2021 16:31:15 +0100
Subject: [PATCH] Integration tests: Add notifications and improve user runtime
 updates

---
 tests/go.mod                       |   6 +-
 tests/go.sum                       |  12 +-
 tests/internal/utils/slice.go      |  16 ++
 tests/internal/utils/slice_test.go |  31 +++
 tests/object_sync_test.conf        |  15 ++
 tests/object_sync_test.go          | 399 ++++++++++++++++++++++++++---
 6 files changed, 440 insertions(+), 39 deletions(-)
 create mode 100644 tests/internal/utils/slice_test.go

diff --git a/tests/go.mod b/tests/go.mod
index f3d16ff3c..ef7025db8 100644
--- a/tests/go.mod
+++ b/tests/go.mod
@@ -10,9 +10,9 @@ require (
 	github.com/jmoiron/sqlx v1.3.4
 	github.com/stretchr/testify v1.7.0
 	go.uber.org/zap v1.19.1
-	golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6 // indirect
+	golang.org/x/net v0.0.0-20211020060615-d418f374d309 // indirect
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	golang.org/x/sys v0.0.0-20211004093028-2c5d950f24ef // indirect
-	google.golang.org/genproto v0.0.0-20211001223012-bfb93cce50d9 // indirect
+	golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 // indirect
+	google.golang.org/genproto v0.0.0-20211027162914-98a5263abeca // indirect
 	google.golang.org/grpc v1.41.0 // indirect
 )
diff --git a/tests/go.sum b/tests/go.sum
index 3f34894c5..e5f4656c2 100644
--- a/tests/go.sum
+++ b/tests/go.sum
@@ -743,8 +743,8 @@ golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
 golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6 h1:Z04ewVs7JhXaYkmDhBERPi41gnltfQpMWDnTnQbaCqk=
-golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211020060615-d418f374d309 h1:A0lJIi+hcTR6aajJH4YqKWwohY4aW9RO7oRMcdv+HKI=
+golang.org/x/net v0.0.0-20211020060615-d418f374d309/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -827,8 +827,8 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211004093028-2c5d950f24ef h1:fPxZ3Umkct3LZ8gK9nbk+DWDJ9fstZa2grBn+lWVKPs=
-golang.org/x/sys v0.0.0-20211004093028-2c5d950f24ef/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 h1:2B5p2L5IfGiD7+b9BOoRMC6DgObAVZV+Fsp050NqXik=
+golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -932,8 +932,8 @@ google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfG
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/genproto v0.0.0-20201110150050-8816d57aaa9a/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20210824181836-a4879c3d0e89/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
-google.golang.org/genproto v0.0.0-20211001223012-bfb93cce50d9 h1:eF1wcrhdz56Vugf8qNX5dD93ItkrhothojQyHXqloe0=
-google.golang.org/genproto v0.0.0-20211001223012-bfb93cce50d9/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20211027162914-98a5263abeca h1:+e+aQDO4/c9KaG8PXWHTc6/+Du6kz+BKcXCSnV4SSTE=
+google.golang.org/genproto v0.0.0-20211027162914-98a5263abeca/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/grpc v0.0.0-20160317175043-d3ddb4469d5a/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
diff --git a/tests/internal/utils/slice.go b/tests/internal/utils/slice.go
index 463a063f3..85821f57a 100644
--- a/tests/internal/utils/slice.go
+++ b/tests/internal/utils/slice.go
@@ -19,3 +19,19 @@ func AnySliceToInterfaceSlice(in interface{}) []interface{} {
 	}
 	return out
 }
+
+func SliceSubsets(in ...string) [][]string {
+	result := make([][]string, 0, 1<<len(in))
+
+	for bitset := 0; bitset < (1 << len(in)); bitset++ {
+		var subset []string
+		for i := 0; i < len(in); i++ {
+			if bitset&(1<<i) != 0 {
+				subset = append(subset, in[i])
+			}
+		}
+		result = append(result, subset)
+	}
+
+	return result
+}
diff --git a/tests/internal/utils/slice_test.go b/tests/internal/utils/slice_test.go
new file mode 100644
index 000000000..c8782267b
--- /dev/null
+++ b/tests/internal/utils/slice_test.go
@@ -0,0 +1,31 @@
+package utils
+
+import (
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestSliceSubsets(t *testing.T) {
+	data := []string{
+		"bla",
+		"blub",
+		"derp",
+	}
+
+	result := SliceSubsets(data...)
+
+	expected := [][]string{
+		nil,
+		{"bla"},
+		{"blub"},
+		{"bla", "blub"},
+		{"derp"},
+		{"bla", "derp"},
+		{"blub", "derp"},
+		{"bla", "blub", "derp"},
+	}
+
+	require.Equal(t, expected, result)
+
+	t.Logf("%#v", result)
+}
diff --git a/tests/object_sync_test.conf b/tests/object_sync_test.conf
index d361c89d5..e4c6da67d 100644
--- a/tests/object_sync_test.conf
+++ b/tests/object_sync_test.conf
@@ -37,3 +37,18 @@ object User "{{.}}-user" {}
 
 object UserGroup "{{.}}-usergroup" {}
 {{end}}
+
+{{range .NotificationUserGroups}}
+object UserGroup "{{.}}" {
+}
+{{end}}
+
+{{range $user, $groups := .NotificationUsers}}
+object User "{{$user}}" {
+  groups = [
+    {{range $group, $_ := $groups}}
+    "{{$group}}",
+    {{end}}
+  ]
+}
+{{end}}
diff --git a/tests/object_sync_test.go b/tests/object_sync_test.go
index 2227c23da..ab33c3185 100644
--- a/tests/object_sync_test.go
+++ b/tests/object_sync_test.go
@@ -17,6 +17,7 @@ import (
 	"go.uber.org/zap"
 	"io"
 	"reflect"
+	"sort"
 	"strings"
 	"testing"
 	"text/template"
@@ -27,23 +28,42 @@ import (
 var testSyncConfRaw string
 var testSyncConfTemplate = template.Must(template.New("testdata.conf").Parse(testSyncConfRaw))
 
+var usergroups = []string{
+	"testusergroup1",
+	"testusergroup2",
+	"testusergroup3",
+}
+
+// Map of users to a set of their groups
+var users = map[string]map[string]struct{}{
+	"testuser1": {"testusergroup1": {}, "testusergroup3": {}},
+	"testuser2": {"testusergroup2": {}},
+	"testuser3": {"testusergroup3": {}, "testusergroup1": {}},
+}
+
 func TestObjectSync(t *testing.T) {
 	logger := it.Logger(t)
 
 	type Data struct {
-		GenericPrefixes []string
-		Hosts           []Host
-		Services        []Service
-		Users           []User
+		GenericPrefixes        []string
+		Hosts                  []Host
+		Services               []Service
+		Users                  []User
+		Notifications          []Notification
+		NotificationUsers      map[string]map[string]struct{}
+		NotificationUserGroups []string
 	}
 	data := &Data{
 		// Some name prefixes to loop over in the template to generate multiple instances of objects,
 		// for example default-host, some-host, and other-host.
 		GenericPrefixes: []string{"default", "some", "other"},
 
-		Hosts:    makeTestSyncHosts(t),
-		Services: makeTestSyncServices(t),
-		Users:    makeTestUsers(t),
+		Hosts:                  makeTestSyncHosts(t),
+		Services:               makeTestSyncServices(t),
+		Users:                  makeTestUsers(t),
+		Notifications:          makeTestNotifications(t),
+		NotificationUsers:      users,
+		NotificationUserGroups: usergroups,
 	}
 
 	r := it.RedisServerT(t)
@@ -64,6 +84,10 @@ func TestObjectSync(t *testing.T) {
 		err := writeIcinga2ConfigObject(conf, user)
 		require.NoError(t, err, "generate icinga2 user config")
 	}
+	for _, notification := range data.Notifications {
+		err := writeIcinga2ConfigObject(conf, notification)
+		require.NoError(t, err, "generate icinga2 notification config")
+	}
 	//logger.Sugar().Infof("config:\n\n%s\n\n", conf.String())
 	i.WriteConfig("etc/icinga2/conf.d/testdata.conf", conf.Bytes())
 	i.EnableIcingaDb(r)
@@ -196,12 +220,32 @@ func TestObjectSync(t *testing.T) {
 
 	t.Run("Notification", func(t *testing.T) {
 		t.Parallel()
-		// TODO(jb): add tests
+		for _, notification := range data.Notifications {
+			notification := notification
+			t.Run("Verify-"+notification.VariantInfoString(), func(t *testing.T) {
+				t.Parallel()
 
-		t.Run("User", func(t *testing.T) { t.Parallel(); t.Skip() })
-		t.Run("UserGroup", func(t *testing.T) { t.Parallel(); t.Skip() })
-		t.Run("Recipient", func(t *testing.T) { t.Parallel(); t.Skip() })
-		t.Run("CustomVar", func(t *testing.T) { t.Parallel(); t.Skip() })
+				eventually.Assert(t, func(t require.TestingT) {
+					notification.verify(t, db)
+				}, 20*time.Second, 1*time.Second)
+
+				if notification.Vars != nil {
+					t.Run("CustomVar", func(t *testing.T) {
+						logger := it.Logger(t)
+						eventually.Assert(t, func(t require.TestingT) {
+							notification.Vars.VerifyCustomVar(t, logger, db, notification)
+						}, 20*time.Second, 1*time.Second)
+					})
+
+					t.Run("CustomVarFlat", func(t *testing.T) {
+						logger := it.Logger(t)
+						eventually.Assert(t, func(t require.TestingT) {
+							notification.Vars.VerifyCustomVarFlat(t, logger, db, notification)
+						}, 20*time.Second, 1*time.Second)
+					})
+				}
+			})
+		}
 	})
 
 	t.Run("TimePeriod", func(t *testing.T) {
@@ -403,33 +447,166 @@ func TestObjectSync(t *testing.T) {
 			t.Run("Update", func(t *testing.T) {
 				t.Parallel()
 
+				userName := utils.UniqueName(t, "user")
+
+				client.CreateObject(t, "users", userName, map[string]interface{}{
+					"attrs": map[string]interface{}{},
+				})
+				require.Eventuallyf(t, func() bool {
+					var count int
+					err := db.Get(&count, "SELECT COUNT(*) FROM user WHERE name = ?", userName)
+					require.NoError(t, err, "querying user count should not fail")
+					return count == 1
+				}, 20*time.Second, 1*time.Second, "user with name=%q should exist in database", userName)
+
 				for _, user := range makeTestUsers(t) {
 					user := user
+					user.Name = userName
 
 					t.Run(user.VariantInfoString(), func(t *testing.T) {
-						t.Parallel()
-
-						client.CreateObject(t, "users", user.Name, map[string]interface{}{
-							"attrs": map[string]interface{}{},
-						})
-						require.Eventuallyf(t, func() bool {
-							var count int
-							err := db.Get(&count, "SELECT COUNT(*) FROM user WHERE name = ?", user.Name)
-							require.NoError(t, err, "querying user count should not fail")
-							return count == 1
-						}, 20*time.Second, 1*time.Second, "user with name=%q should exist in database", user.Name)
-
-						client.UpdateObject(t, "users", user.Name, map[string]interface{}{
+						client.UpdateObject(t, "users", userName, map[string]interface{}{
 							"attrs": makeIcinga2ApiAttributes(user),
 						})
 
 						eventually.Assert(t, func(t require.TestingT) {
 							verifyIcingaDbRow(t, db, user)
 						}, 20*time.Second, 1*time.Second)
+					})
+				}
 
-						client.DeleteObject(t, "users", user.Name, false)
+				client.DeleteObject(t, "users", userName, false)
+			})
+		})
+
+		t.Run("Notifications", func(t *testing.T) {
+			t.Parallel()
+
+			for _, notification := range makeTestNotifications(t) {
+				notification := notification
+
+				t.Run("CreateAndDelete-"+notification.VariantInfoString(), func(t *testing.T) {
+					t.Parallel()
+
+					client.CreateObject(t, "notifications", notification.fullName(), map[string]interface{}{
+						"attrs": makeIcinga2ApiAttributes(notification),
 					})
+
+					eventually.Assert(t, func(t require.TestingT) {
+						notification.verify(t, db)
+					}, 20*time.Second, 200*time.Millisecond)
+
+					client.DeleteObject(t, "notifications", notification.fullName(), false)
+
+					require.Eventuallyf(t, func() bool {
+						var count int
+						err := db.Get(&count, "SELECT COUNT(*) FROM notification WHERE name = ?", notification.fullName())
+						require.NoError(t, err, "querying notification count should not fail")
+						return count == 0
+					}, 20*time.Second, 200*time.Millisecond, "notification with name=%q should be removed from database", notification.fullName())
+				})
+			}
+
+			t.Run("Update", func(t *testing.T) {
+				t.Parallel()
+
+				baseNotification := Notification{
+					Name:        utils.UniqueName(t, "notification"),
+					HostName:    newString("default-host"),
+					ServiceName: newString("default-service"),
+					Command:     "default-notificationcommand",
+					Users:       []string{"default-user"},
+					UserGroups:  []string{"default-usergroup"},
+					Interval:    1800,
 				}
+
+				client.CreateObject(t, "notifications", baseNotification.fullName(), map[string]interface{}{
+					"attrs": makeIcinga2ApiAttributes(baseNotification),
+				})
+
+				require.Eventuallyf(t, func() bool {
+					var count int
+					err := db.Get(&count, "SELECT COUNT(*) FROM notification WHERE name = ?", baseNotification.fullName())
+					require.NoError(t, err, "querying notification count should not fail")
+					return count == 1
+				}, 20*time.Second, 200*time.Millisecond, "notification with name=%q should exist in database", baseNotification.fullName())
+
+				// TODO: Currently broken, but has been tested manually multiple times. Gets more time after RC2
+				/*t.Run("CreateAndDeleteUser", func(t *testing.T) {
+					groupName := utils.UniqueName(t, "group")
+					userName := "testuser112312321"
+
+					// Create usergroup
+					client.CreateObject(t, "usergroups", groupName, nil)
+
+					baseNotification.UserGroups = []string{groupName}
+					client.UpdateObject(t, "notifications", baseNotification.fullName(), map[string]interface{}{
+						"attrs": map[string]interface{}{
+							"user_groups": baseNotification.UserGroups,
+						},
+					})
+
+					eventually.Assert(t, func(t require.TestingT) {
+						baseNotification.verify(t, db)
+					}, 20*time.Second, 1*time.Second)
+
+					// Create user
+					users[userName] = map[string]struct{}{groupName: {}}
+					client.CreateObject(t, "users", userName, map[string]interface{}{
+						"attrs": map[string]interface{}{
+							"groups": baseNotification.UserGroups,
+						},
+					})
+
+					require.Eventuallyf(t, func() bool {
+						var count int
+						err := db.Get(&count, "SELECT COUNT(*) FROM user WHERE name = ?", userName)
+						require.NoError(t, err, "querying user count should not fail")
+						return count == 1
+					}, 20*time.Second, 200*time.Millisecond, "user with name=%q should exist in database", userName)
+
+					eventually.Assert(t, func(t require.TestingT) {
+						baseNotification.verify(t, db)
+					}, 20*time.Second, 1*time.Second)
+
+					// Delete user
+					delete(users, userName)
+					client.DeleteObject(t, "users", userName, false)
+
+					eventually.Assert(t, func(t require.TestingT) {
+						baseNotification.verify(t, db)
+					}, 20*time.Second, 1*time.Second)
+
+					// Remove group
+					baseNotification.UserGroups = []string{}
+					client.UpdateObject(t, "notifications", baseNotification.fullName(), map[string]interface{}{
+						"attrs": map[string]interface{}{
+							"user_groups": baseNotification.UserGroups,
+						},
+					})
+
+					client.DeleteObject(t, "usergroups", groupName, false)
+
+					eventually.Assert(t, func(t require.TestingT) {
+						baseNotification.verify(t, db)
+					}, 20*time.Second, 1*time.Second)
+				})*/
+
+				for _, notification := range makeTestNotifications(t) {
+					notification := notification
+					notification.Name = baseNotification.Name
+
+					t.Run(notification.VariantInfoString(), func(t *testing.T) {
+						client.UpdateObject(t, "notifications", notification.fullName(), map[string]interface{}{
+							"attrs": makeIcinga2ApiAttributes(notification),
+						})
+
+						eventually.Assert(t, func(t require.TestingT) {
+							notification.verify(t, db)
+						}, 20*time.Second, 200*time.Millisecond)
+					})
+				}
+
+				client.DeleteObject(t, "notifications", baseNotification.fullName(), false)
 			})
 		})
 
@@ -710,6 +887,166 @@ func makeTestUsers(t *testing.T) []User {
 	return users
 }
 
+type Notification struct {
+	Name        string            `                                  icingadb:"name"`
+	HostName    *string           `icinga2:"host_name"               icingadb:"host.name"`
+	ServiceName *string           `icinga2:"service_name"            icingadb:"service.name"`
+	Command     string            `icinga2:"command"                 icingadb:"notificationcommand.name"`
+	Times       map[string]string `icinga2:"times"`
+	Interval    int               `icinga2:"interval"                icingadb:"notification_interval"`
+	Period      *string           `icinga2:"period"                  icingadb:"timeperiod.name"`
+	//Zone      string                   `icinga2:"zone"                    icingadb:"zone.name"`
+	Types      value.NotificationTypes  `icinga2:"types"                   icingadb:"types"`
+	States     value.NotificationStates `icinga2:"states"                  icingadb:"states"`
+	Users      []string                 `icinga2:"users"`
+	UserGroups []string                 `icinga2:"user_groups"`
+	Vars       *CustomVarTestData       `icinga2:"vars"`
+
+	utils.VariantInfo
+}
+
+func (n Notification) fullName() string {
+	if n.ServiceName == nil {
+		return *n.HostName + "!" + n.Name
+	} else {
+		return *n.HostName + "!" + *n.ServiceName + "!" + n.Name
+	}
+}
+
+func (n Notification) verify(t require.TestingT, db *sqlx.DB) {
+	verifyIcingaDbRow(t, db, n)
+
+	// Check if the "notification_user" table has been populated correctly
+	{
+		query := "SELECT u.name FROM notification n JOIN notification_user nu ON n.id = nu.notification_id JOIN user u ON u.id = nu.user_id WHERE n.name = ? ORDER BY u.name"
+		var rows []string
+		err := db.Select(&rows, query, n.fullName())
+		require.NoError(t, err, "mysql query")
+
+		expected := append([]string(nil), n.Users...)
+		sort.Strings(expected)
+
+		assert.Equal(t, expected, rows, "Users in database should be equal")
+	}
+
+	// Check if the "notification_groups" table has been populated correctly
+	{
+		query := "SELECT ug.name FROM notification n JOIN notification_usergroup ng ON n.id = ng.notification_id JOIN usergroup ug ON ug.id = ng.usergroup_id WHERE n.name = ? ORDER BY ug.name"
+		var rows []string
+		err := db.Select(&rows, query, n.fullName())
+		require.NoError(t, err, "mysql query")
+
+		expected := append([]string(nil), n.UserGroups...)
+		sort.Strings(expected)
+		require.Equal(t, expected, rows, "Usergroups in database should be equal")
+	}
+
+	// Check if the "notification_recipients" table has been populated correctly
+	{
+		type Row struct {
+			User  *string `db:"username"`
+			Group *string `db:"groupname"`
+		}
+
+		var expected []Row
+
+		for _, user := range n.Users {
+			expected = append(expected, Row{User: newString(user)})
+		}
+
+		for _, userGroup := range n.UserGroups {
+			expected = append(expected, Row{Group: newString(userGroup)})
+			for user, groups := range users {
+				if _, ok := groups[userGroup]; ok {
+					expected = append(expected, Row{User: newString(user), Group: newString(userGroup)})
+				}
+			}
+		}
+
+		sort.Slice(expected, func(i, j int) bool {
+			r1 := expected[i]
+			r2 := expected[j]
+
+			stringComparePtr := func(a, b *string) int {
+				if a == nil && b == nil {
+					return 0
+				} else if a == nil {
+					return -1
+				} else if b == nil {
+					return 1
+				}
+
+				return strings.Compare(*a, *b)
+			}
+
+			switch stringComparePtr(r1.User, r2.User) {
+			case -1:
+				return true
+			case 1:
+				return false
+			default:
+				return stringComparePtr(r1.Group, r2.Group) == -1
+			}
+		})
+
+		query := "SELECT u.name AS username, ug.name AS groupname FROM notification n " +
+			"JOIN notification_recipient nr ON n.id = nr.notification_id " +
+			"LEFT JOIN user u ON u.id = nr.user_id " +
+			"LEFT JOIN usergroup ug ON ug.id = nr.usergroup_id " +
+			"WHERE n.name = ? " +
+			"ORDER BY u.name, ug.name"
+
+		var rows []Row
+		err := db.Select(&rows, query, n.fullName())
+
+		require.NoError(t, err, "mysql query")
+		require.Equal(t, expected, rows, "Recipients in database should be equal")
+	}
+}
+
+func makeTestNotifications(t *testing.T) []Notification {
+	notification := Notification{
+		HostName:    newString("default-host"),
+		ServiceName: newString("default-service"),
+		Command:     "default-notificationcommand",
+		Users:       []string{"default-user", "testuser1", "testuser2", "testuser3"},
+		UserGroups:  []string{"default-usergroup", "testusergroup1", "testusergroup2", "testusergroup3"},
+		Interval:    1800,
+	}
+
+	notifications := utils.MakeVariants(notification).
+		//Vary("TimesBegin", 5, 999, 23980, 525, 666, 0).
+		//Vary("TimesEnd", 0, 453, 74350, 423, 235, 63477).
+		Vary("Interval", 5, 453, 74350, 423, 235, 63477).
+		Vary("Period", newString("some-timeperiod"), newString("other-timeperiod")).
+		Vary("Types",
+			value.NotificationTypes{"DowntimeStart", "DowntimeEnd", "DowntimeRemoved"},
+			value.NotificationTypes{"Custom"},
+			value.NotificationTypes{"Acknowledgement"},
+			value.NotificationTypes{"Problem", "Recovery"},
+			value.NotificationTypes{"FlappingStart", "FlappingEnd"},
+			value.NotificationTypes{"DowntimeStart", "Problem", "FlappingStart"},
+			value.NotificationTypes{"DowntimeEnd", "DowntimeRemoved", "Recovery", "FlappingEnd"},
+			value.NotificationTypes{"DowntimeStart", "DowntimeEnd", "DowntimeRemoved", "Custom", "Acknowledgement", "Problem", "Recovery", "FlappingStart", "FlappingEnd"},
+			value.NotificationTypes{"Custom", "Acknowledgement"},
+		).
+		Vary("States",
+			value.NotificationStates{},
+			value.NotificationStates{"OK", "Warning", "Critical", "Unknown"},
+			value.NotificationStates{"OK", "Unknown"}).
+		Vary("Users", localutils.AnySliceToInterfaceSlice(localutils.SliceSubsets(
+			"default-user", "some-user", "other-user", "testuser1", "testuser2", "testuser3"))...).
+		Vary("UserGroups", localutils.AnySliceToInterfaceSlice(localutils.SliceSubsets(
+			"default-usergroup", "some-usergroup", "other-usergroup", "testusergroup1", "testusergroup2", "testusergroup3"))...).
+		ResultAsBaseTypeSlice().([]Notification)
+
+	for i := range notifications {
+		notifications[i].Name = utils.UniqueName(t, "notification")
+	}
+
+	return notifications
+}
+
 // writeIcinga2ConfigObjects emits config objects as icinga2 DSL to a writer
 // based on the type of obj and its field having icinga2 struct tags.
 func writeIcinga2ConfigObject(w io.Writer, obj interface{}) error {
@@ -764,6 +1101,10 @@ func verifyIcingaDbRow(t require.TestingT, db *sqlx.DB, obj interface{}) {
 	typ := o.Type()
 	typeName := typ.Name()
 
+	if notification, ok := obj.(Notification); ok {
+		name = notification.fullName()
+	}
+
 	type ColumnValueExpected struct {
 		Column   string
 		Value    interface{}
@@ -791,7 +1132,7 @@ func verifyIcingaDbRow(t require.TestingT, db *sqlx.DB, obj interface{}) {
 	joins := make(map[string]struct{})
 
 	for fieldIndex := 0; fieldIndex < typ.NumField(); fieldIndex++ {
-		if col := typ.Field(fieldIndex).Tag.Get("icingadb"); col != "" {
+		if col := typ.Field(fieldIndex).Tag.Get("icingadb"); col != "" && col != "name" {
 			if val := o.Field(fieldIndex).Interface(); val != nil {
 				dbVal := value.ToIcingaDb(val)
 				scanVal := reflect.New(reflect.TypeOf(dbVal)).Interface()
@@ -835,9 +1176,7 @@ func verifyIcingaDbRow(t require.TestingT, db *sqlx.DB, obj interface{}) {
 // newString allocates a new *string and initializes it. This helper function exists as
 // there seems to be no way to achieve this within a single statement.
 func newString(s string) *string {
-	p := new(string)
-	*p = s
-	return p
+	return &s
 }
 
 type CustomVarTestData struct {