Added tests for workspace detail metrics

Moderate refactoring Signed-off-by: Danny Kopping <danny@coder.com>
coder · dannykopping · Apr 2, 2024 · Mar 25, 2024 · Mar 26, 2024 · Mar 26, 2024
commit 2f5a9484263f404114fd721e5b0e3d22e3229a8b
diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
@@ -403,6 +403,16 @@ func (q *FakeQuerier) convertToWorkspaceRowsNoLock(ctx context.Context, workspac
 					break
 				}
 			}
+
+			if pj, err := q.GetProvisionerJobByID(ctx, build.JobID); err == nil {
+				wr.LatestBuildStatus = database.NullProvisionerJobStatus{ProvisionerJobStatus: pj.JobStatus, Valid: true}
+			}
+
+			wr.LatestBuildTransition = build.Transition
+		}
+
+		if u, err := q.GetUserByID(ctx, w.OwnerID); err == nil {
+			wr.Username = u.Username
 		}
 
 		rows = append(rows, wr)

diff --git a/coderd/prometheusmetrics/prometheusmetrics.go b/coderd/prometheusmetrics/prometheusmetrics.go
@@ -160,7 +160,7 @@ func Workspaces(ctx context.Context, logger slog.Logger, registerer prometheus.R
 				}
 			}
 
-			workspacesDetail.WithLabelValues(buildStatus, w.TemplateName, w.TemplateVersionName.String, w.Name, w.Username, string(w.LatestBuildTransition)).Set(1)
+			workspaceDetails.WithLabelValues(buildStatus, w.TemplateName, w.TemplateVersionName.String, w.Name, w.Username, string(w.LatestBuildTransition)).Set(1)
 		}
 	}
 

diff --git a/coderd/prometheusmetrics/prometheusmetrics_test.go b/coderd/prometheusmetrics/prometheusmetrics_test.go
@@ -5,12 +5,14 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"math/rand"
 	"os"
 	"reflect"
 	"sync/atomic"
 	"testing"
 	"time"
 
+	"github.com/coder/coder/v2/cryptorand"
 	"github.com/google/uuid"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/assert"
@@ -110,7 +112,7 @@ func TestActiveUsers(t *testing.T) {
 	}
 }
 
-func TestWorkspaces(t *testing.T) {
+func TestWorkspaceStatuses(t *testing.T) {
 	t.Parallel()
 
 	insertRunning := func(db database.Store) database.ProvisionerJob {
@@ -229,33 +231,273 @@ func TestWorkspaces(t *testing.T) {
 		t.Run(tc.Name, func(t *testing.T) {
 			t.Parallel()
 			registry := prometheus.NewRegistry()
-			closeFunc, err := prometheusmetrics.Workspaces(context.Background(), slogtest.Make(t, nil), registry, tc.Database(), time.Millisecond)
+			closeFunc, err := prometheusmetrics.Workspaces(context.Background(), slogtest.Make(t, nil), registry, tc.Database(), testutil.IntervalFast)
 			require.NoError(t, err)
 			t.Cleanup(closeFunc)
 
 			require.Eventually(t, func() bool {
 				metrics, err := registry.Gather()
 				assert.NoError(t, err)
-				if len(metrics) < 1 {
-					return false
-				}
 				sum := 0
-				for _, metric := range metrics[0].Metric {
-					count, ok := tc.Status[codersdk.ProvisionerJobStatus(metric.Label[0].GetValue())]
-					if metric.Gauge.GetValue() == 0 {
+				for _, m := range metrics {
+					if m.GetName() != "coderd_api_workspace_latest_build_total" {
 						continue
 					}
-					if !ok {
-						t.Fail()
-					}
-					if metric.Gauge.GetValue() != float64(count) {
-						return false
+
+					for _, metric := range m.Metric {
+						count, ok := tc.Status[codersdk.ProvisionerJobStatus(metric.Label[0].GetValue())]
+						if metric.Gauge.GetValue() == 0 {
+							continue
+						}
+						if !ok {
+							t.Fail()
+						}
+						if metric.Gauge.GetValue() != float64(count) {
+							return false
+						}
+						sum += int(metric.Gauge.GetValue())
 					}
-					sum += int(metric.Gauge.GetValue())
 				}
 				t.Logf("sum %d == total %d", sum, tc.Total)
 				return sum == tc.Total
-			}, testutil.WaitShort, testutil.IntervalFast)
+			}, testutil.WaitSuperShort, testutil.IntervalFast)
+		})
+	}
+}
+
+func TestWorkspaceDetails(t *testing.T) {
+	t.Parallel()
+
+	templateA := uuid.New()
+	templateVersionA := uuid.New()
+	templateB := uuid.New()
+	templateVersionB := uuid.New()
+
+	insertTemplates := func(db database.Store) {
+		require.NoError(t, db.InsertTemplate(context.Background(), database.InsertTemplateParams{
+			ID:                  templateA,
+			Name:                "template-a",
+			Provisioner:         database.ProvisionerTypeTerraform,
+			MaxPortSharingLevel: database.AppSharingLevelAuthenticated,
+		}))
+
+		require.NoError(t, db.InsertTemplateVersion(context.Background(), database.InsertTemplateVersionParams{
+			ID:         templateVersionA,
+			TemplateID: uuid.NullUUID{UUID: templateA},
+			Name:       "version-1a",
+		}))
+
+		require.NoError(t, db.InsertTemplate(context.Background(), database.InsertTemplateParams{
+			ID:                  templateB,
+			Name:                "template-b",
+			Provisioner:         database.ProvisionerTypeTerraform,
+			MaxPortSharingLevel: database.AppSharingLevelAuthenticated,
+		}))
+
+		require.NoError(t, db.InsertTemplateVersion(context.Background(), database.InsertTemplateVersionParams{
+			ID:         templateVersionB,
+			TemplateID: uuid.NullUUID{UUID: templateB},
+			Name:       "version-1b",
+		}))
+	}
+
+	insertUser := func(db database.Store) database.User {
+		username, err := cryptorand.String(8)
+		require.NoError(t, err)
+
+		user, err := db.InsertUser(context.Background(), database.InsertUserParams{
+			ID:        uuid.New(),
+			Username:  username,
+			LoginType: database.LoginTypeNone,
+		})
+		require.NoError(t, err)
+
+		return user
+	}
+
+	insertRunning := func(db database.Store) database.ProvisionerJob {
+		var template, templateVersion uuid.UUID
+		if rand.Intn(10) > 5 {
+			template = templateB
+			templateVersion = templateVersionB
+		} else {
+			template = templateA
+			templateVersion = templateVersionA
+		}
+
+		workspace, err := db.InsertWorkspace(context.Background(), database.InsertWorkspaceParams{
+			ID:               uuid.New(),
+			OwnerID:          insertUser(db).ID,
+			Name:             uuid.NewString(),
+			TemplateID:       template,
+			AutomaticUpdates: database.AutomaticUpdatesNever,
+		})
+		require.NoError(t, err)
+
+		job, err := db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
+			ID:            uuid.New(),
+			CreatedAt:     dbtime.Now(),
+			UpdatedAt:     dbtime.Now(),
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+			Type:          database.ProvisionerJobTypeWorkspaceBuild,
+		})
+		require.NoError(t, err)
+		err = db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
+			ID:                uuid.New(),
+			WorkspaceID:       workspace.ID,
+			JobID:             job.ID,
+			BuildNumber:       1,
+			Transition:        database.WorkspaceTransitionStart,
+			Reason:            database.BuildReasonInitiator,
+			TemplateVersionID: templateVersion,
+		})
+		require.NoError(t, err)
+		// This marks the job as started.
+		_, err = db.AcquireProvisionerJob(context.Background(), database.AcquireProvisionerJobParams{
+			OrganizationID: job.OrganizationID,
+			StartedAt: sql.NullTime{
+				Time:  dbtime.Now(),
+				Valid: true,
+			},
+			Types: []database.ProvisionerType{database.ProvisionerTypeEcho},
+		})
+		require.NoError(t, err)
+		return job
+	}
+
+	insertCanceled := func(db database.Store) {
+		job := insertRunning(db)
+		err := db.UpdateProvisionerJobWithCancelByID(context.Background(), database.UpdateProvisionerJobWithCancelByIDParams{
+			ID: job.ID,
+			CanceledAt: sql.NullTime{
+				Time:  dbtime.Now(),
+				Valid: true,
+			},
+		})
+		require.NoError(t, err)
+		err = db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
+			ID: job.ID,
+			CompletedAt: sql.NullTime{
+				Time:  dbtime.Now(),
+				Valid: true,
+			},
+		})
+		require.NoError(t, err)
+	}
+
+	insertFailed := func(db database.Store) {
+		job := insertRunning(db)
+		err := db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
+			ID: job.ID,
+			CompletedAt: sql.NullTime{
+				Time:  dbtime.Now(),
+				Valid: true,
+			},
+			Error: sql.NullString{
+				String: "failed",
+				Valid:  true,
+			},
+		})
+		require.NoError(t, err)
+	}
+
+	insertSuccess := func(db database.Store) {
+		job := insertRunning(db)
+		err := db.UpdateProvisionerJobWithCompleteByID(context.Background(), database.UpdateProvisionerJobWithCompleteByIDParams{
+			ID: job.ID,
+			CompletedAt: sql.NullTime{
+				Time:  dbtime.Now(),
+				Valid: true,
+			},
+		})
+		require.NoError(t, err)
+	}
+
+	for _, tc := range []struct {
+		Name               string
+		Database           func() database.Store
+		ExpectedSeries     int
+		ExpectedStatuses   map[codersdk.ProvisionerJobStatus]int
+		ExpectedWorkspaces int
+	}{{
+		Name: "None",
+		Database: func() database.Store {
+			return dbmem.New()
+		},
+		ExpectedSeries:     0,
+		ExpectedWorkspaces: 0,
+	}, {
+		Name: "Multiple",
+		Database: func() database.Store {
+			db := dbmem.New()
+			insertTemplates(db)
+			insertCanceled(db)
+			insertFailed(db)
+			insertFailed(db)
+			insertSuccess(db)
+			insertSuccess(db)
+			insertSuccess(db)
+			insertRunning(db)
+			return db
+		},
+		ExpectedSeries:     7,
+		ExpectedWorkspaces: 7,
+		ExpectedStatuses: map[codersdk.ProvisionerJobStatus]int{
+			codersdk.ProvisionerJobCanceled:  1,
+			codersdk.ProvisionerJobFailed:    2,
+			codersdk.ProvisionerJobSucceeded: 3,
+			codersdk.ProvisionerJobRunning:   1,
+		},
+	}} {
+		tc := tc
+		t.Run(tc.Name, func(t *testing.T) {
+			t.Parallel()
+			registry := prometheus.NewRegistry()
+			closeFunc, err := prometheusmetrics.Workspaces(context.Background(), slogtest.Make(t, nil), registry, tc.Database(), testutil.IntervalFast)
+			require.NoError(t, err)
+			t.Cleanup(closeFunc)
+
+			require.Eventually(t, func() bool {
+				metrics, err := registry.Gather()
+				assert.NoError(t, err)
+				stMap := map[codersdk.ProvisionerJobStatus]int{}
+				wMap := map[string]struct{}{}
+				for _, m := range metrics {
+					if m.GetName() != "coderd_api_workspace_detail" {
+						continue
+					}
+
+					for _, metric := range m.Metric {
+						for _, l := range metric.Label {
+							if l == nil {
+								continue
+							}
+
+							switch l.GetName() {
+							case "status":
+								status := codersdk.ProvisionerJobStatus(l.GetValue())
+								stMap[status] += int(metric.Gauge.GetValue())
+							case "workspace_name":
+								wMap[l.GetValue()] = struct{}{}
+							}
+						}
+					}
+				}
+
+				stSum := 0
+				for st, count := range stMap {
+					if tc.ExpectedStatuses[st] != count {
+						return false
+					}
+
+					stSum += count
+				}
+
+				t.Logf("status series = %d, expected == %d", stSum, tc.ExpectedSeries)
+				t.Logf("workspace series = %d, expected == %d", len(wMap), tc.ExpectedWorkspaces)
+				return stSum == tc.ExpectedSeries && len(wMap) == tc.ExpectedWorkspaces
+			}, testutil.WaitSuperShort, testutil.IntervalFast)
 		})
 	}
 }

diff --git a/testutil/duration.go b/testutil/duration.go
@@ -9,10 +9,11 @@ import (
 // Constants for timing out operations, usable for creating contexts
 // that timeout or in require.Eventually.
 const (
-	WaitShort     = 10 * time.Second
-	WaitMedium    = 15 * time.Second
-	WaitLong      = 25 * time.Second
-	WaitSuperLong = 60 * time.Second
+	WaitSuperShort = time.Second
+	WaitShort      = 10 * time.Second
+	WaitMedium     = 15 * time.Second
+	WaitLong       = 25 * time.Second
+	WaitSuperLong  = 60 * time.Second
 )
 
 // Constants for delaying repeated operations, e.g. in
-Original file line number
+Diff line change
@@ Expand Up @@
     				}
     			}
-    			workspacesDetail.WithLabelValues(buildStatus, w.TemplateName, w.TemplateVersionName.String, w.Name, w.Username, string(w.LatestBuildTransition)).Set(1)
+    			workspaceDetails.WithLabelValues(buildStatus, w.TemplateName, w.TemplateVersionName.String, w.Name, w.Username, string(w.LatestBuildTransition)).Set(1)
     		}
     	}
@@ Expand Down @@