Assert SlaLifeCycle integration tests gracefully

Author: yhabteab

tests/object_sync_test.go

@@ -112,7 +112,7 @@ func TestObjectSync(t *testing.T) {
 	t.Run("Host", func(t *testing.T) {
 		t.Parallel()
 
-		for hostId, host := range data.Hosts {
+		for _, host := range data.Hosts {
 			t.Run("Verify-"+host.VariantInfoString(), func(t *testing.T) {
 				t.Parallel()
 
@@ -137,23 +137,13 @@ func TestObjectSync(t *testing.T) {
 				}
 			})
 
-			t.Run("Verify-SlaLifeCycle-"+fmt.Sprint(hostId), func(t *testing.T) {
-				eventually.Assert(t, func(t require.TestingT) {
-					var count int
-					stmt := `SELECT COUNT(*) FROM "sla_lifecycle" INNER JOIN "host" ON "host"."id"="sla_lifecycle"."host_id" WHERE "service_id" IS NULL AND "host"."name"=?`
-					err := db.Get(&count, db.Rebind(stmt), host.Name)
-
-					require.NoError(t, err, "querying host sla lifecycle count should not fail")
-					require.True(t, count == 1, "there should be one sla lifecycle entry for host %q", host.Name)
-				}, 20*time.Second, 1*time.Second)
-			})
 		}
 	})
 
 	t.Run("Service", func(t *testing.T) {
 		t.Parallel()
 
-		for serviceId, service := range data.Services {
+		for _, service := range data.Services {
 			t.Run("Verify-"+service.VariantInfoString(), func(t *testing.T) {
 				t.Parallel()
 
@@ -177,18 +167,41 @@ func TestObjectSync(t *testing.T) {
 					})
 				}
 			})
+		}
+	})
 
-			t.Run("Verify-SlaLifeCycle-"+fmt.Sprint(serviceId), func(t *testing.T) {
-				eventually.Assert(t, func(t require.TestingT) {
-					var count int
-					stmt := `SELECT COUNT(*) FROM "sla_lifecycle" INNER JOIN "service" ON "service"."id"="sla_lifecycle"."service_id" WHERE "service"."name" = ?`
-					err := db.Get(&count, db.Rebind(stmt), service.Name)
+	t.Run("SlaLifeCycle", func(t *testing.T) {
+		t.Parallel()
 
-					require.NoError(t, err, "querying service sla lifecycle should not fail")
-					require.True(t, count == 1, "there should be one sla lifecycle entry for service %q", service.Name)
-				}, 20*time.Second, 1*time.Second)
-			})
-		}
+		slinfo := &SlaLifecycle{CreateTime: types.UnixMilli(time.Now())}
+
+		t.Run("Hosts", func(t *testing.T) {
+			t.Parallel()
+
+			for hostId, host := range data.Hosts {
+				t.Run("Verify-Host-"+fmt.Sprint(hostId), func(t *testing.T) {
+					t.Parallel()
+
+					eventually.Assert(t, func(t require.TestingT) {
+						verifySlaLifeCycleRow(t, db, slinfo, host.Name, "")
+					}, 20*time.Second, 1*time.Second)
+				})
+			}
+		})
+
+		t.Run("Services", func(t *testing.T) {
+			t.Parallel()
+
+			for serviceId, service := range data.Services {
+				t.Run("Verify-Service-"+fmt.Sprint(serviceId), func(t *testing.T) {
+					t.Parallel()
+
+					eventually.Assert(t, func(t require.TestingT) {
+						verifySlaLifeCycleRow(t, db, slinfo, *service.HostName, service.Name)
+					}, 20*time.Second, 1*time.Second)
+				})
+			}
+		})
 	})
 
 	t.Run("HostGroup", func(t *testing.T) {
@@ -379,22 +392,6 @@ func TestObjectSync(t *testing.T) {
 						require.NoError(t, err, "querying service count should not fail")
 						return count == 0
 					}, 20*time.Second, 1*time.Second, "service with name=%q should be removed from database", service.Name)
-
-					eventually.Assert(t, func(t require.TestingT) {
-						var expectedResult []struct {
-							CreateTime types.UnixMilli `db:"create_time"`
-							DeleteTime types.UnixMilli `db:"delete_time"`
-						}
-						stmt := `SELECT "create_time", "delete_time" FROM "sla_lifecycle" 
-									INNER JOIN "service" ON "service"."id"="sla_lifecycle"."service_id"
-									WHERE "service"."name" = ?`
-						err := db.Select(&expectedResult, db.Rebind(stmt), service.Name)
-						require.NoError(t, err, "querying service sla lifecycle should not fail")
-
-						require.True(t, len(expectedResult) == 1)
-						require.False(t, expectedResult[0].CreateTime.Time().IsZero())
-						require.False(t, expectedResult[0].DeleteTime.Time().IsZero())
-					}, 20*time.Second, 1*time.Second)
 				})
 			}
 
@@ -452,6 +449,34 @@ func TestObjectSync(t *testing.T) {
 			})
 		})
 
+		t.Run("SlaLifeCycle", func(t *testing.T) {
+			t.Parallel()
+
+			for serviceId, service := range makeTestSyncServices(t) {
+				//service.Name += fmt.Sprint(serviceId)
+
+				t.Run("Verify-Service-"+fmt.Sprint(serviceId), func(t *testing.T) {
+					t.Parallel()
+
+					client.CreateObject(t, "services", *service.HostName+"!"+service.Name, map[string]interface{}{
+						"attrs": makeIcinga2ApiAttributes(service, false),
+					})
+
+					slinfo := &SlaLifecycle{CreateTime: types.UnixMilli(time.Now())}
+					eventually.Assert(t, func(t require.TestingT) {
+						verifySlaLifeCycleRow(t, db, slinfo, *service.HostName, service.Name)
+					}, 20*time.Second, 1*time.Second)
+
+					client.DeleteObject(t, "services", *service.HostName+"!"+service.Name, false)
+
+					slinfo.DeleteTime = types.UnixMilli(time.Now())
+					eventually.Assert(t, func(t require.TestingT) {
+						verifySlaLifeCycleRow(t, db, slinfo, "", "")
+					}, 20*time.Second, 1*time.Second)
+				})
+			}
+		})
+
 		t.Run("User", func(t *testing.T) {
 			t.Parallel()
 
@@ -1222,6 +1247,68 @@ func verifyIcingaDbRow(t require.TestingT, db *sqlx.DB, obj interface{}) {
 	require.False(t, rows.Next(), "SQL query should return only one row: %s", query)
 }
 
+func verifySlaLifeCycleRow(t require.TestingT, db *sqlx.DB, slinfo *SlaLifecycle, host string, service string) {
+	query := `SELECT "create_time", "delete_time", "sla_lifecycle"."host_id", "sla_lifecycle"."service_id" FROM "sla_lifecycle"`
+	var args []interface{}
+	if !slinfo.HostID.Valid() {
+		query += ` INNER JOIN "host" ON "host"."id"="sla_lifecycle"."host_id"`
+		where := ` WHERE "host"."name"=?`
+
+		args = append(args, host)
+		if service == "" {
+			where += ` AND "service_id" IS NULL`
+		} else {
+			query += ` INNER JOIN "service" ON "service"."id"="sla_lifecycle"."service_id"`
+			where += ` AND "service"."name"=?`
+			args = append(args, service)
+		}
+
+		query += where + ` AND "delete_time" = 0`
+	} else {
+		query += ` WHERE "host_id"=?`
+		args = []interface{}{slinfo.HostID}
+		if !slinfo.ServiceID.Valid() {
+			query += ` AND "service_id" IS NULL`
+		} else {
+			query += ` AND "service_id"=?`
+			args = append(args, slinfo.ServiceID)
+		}
+	}
+
+	var resultSet []SlaLifecycle
+	err := db.Select(&resultSet, db.Rebind(query), args...)
+	require.NoError(t, err, "querying sla lifecycle should not fail: Query: %q", query)
+
+	require.Len(t, resultSet, 1, "there should be one sla lifecycle entry")
+
+	result := resultSet[0]
+	zerotimestamp := time.Unix(0, 0)
+
+	require.NotEqual(t, zerotimestamp, result.CreateTime.Time())
+	assert.WithinDuration(t, slinfo.CreateTime.Time(), result.CreateTime.Time(), time.Minute)
+
+	if slinfo.DeleteTime.Time().IsZero() {
+		// We can't join on the host/service tables, as the sla lifecycle entries may reference entries that have
+		// already been deleted. So cache the host/service id to use as a filter when asserting the sla lifecycles
+		// delete event.
+		slinfo.HostID = result.HostID
+		slinfo.ServiceID = result.ServiceID
+
+		require.Equal(t, zerotimestamp, result.DeleteTime.Time())
+	} else {
+		require.NotEqual(t, zerotimestamp, result.DeleteTime.Time())
+		require.Less(t, result.CreateTime.Time(), result.DeleteTime.Time())
+		assert.WithinDuration(t, slinfo.DeleteTime.Time(), result.DeleteTime.Time(), time.Minute)
+	}
+}
+
+type SlaLifecycle struct {
+	CreateTime types.UnixMilli `db:"create_time"`
+	DeleteTime types.UnixMilli `db:"delete_time"`
+	HostID     types.Binary    `db:"host_id"`
+	ServiceID  types.Binary    `db:"service_id"`
+}
+
 // 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 {