chore: Use dbgen in unit test (#6111)

* chore: Use dbgen in unit test

- organizationparam_test
- templateparam_test

* Use dbgen in all unit tests vs insert methods

* fixup! Use dbgen in all unit tests vs insert methods

---------

Co-authored-by: Cian Johnston <cian@coder.com>

coderd/httpmw/organizationparam_test.go

@@ -2,12 +2,9 @@ package httpmw_test
 
 import (
 	"context"
-	"crypto/sha256"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-	"time"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/google/uuid"
@@ -15,9 +12,9 @@ import (
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbfake"
+	"github.com/coder/coder/coderd/database/dbgen"
 	"github.com/coder/coder/coderd/httpmw"
 	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/cryptorand"
 )
 
 func TestOrganizationParam(t *testing.T) {
@@ -25,36 +22,16 @@ func TestOrganizationParam(t *testing.T) {
 
 	setupAuthentication := func(db database.Store) (*http.Request, database.User) {
 		var (
-			id, secret = randomAPIKeyParts()
-			r          = httptest.NewRequest("GET", "/", nil)
-			hashed     = sha256.Sum256([]byte(secret))
+			r = httptest.NewRequest("GET", "/", nil)
 		)
-		r.Header.Set(codersdk.SessionTokenHeader, fmt.Sprintf("%s-%s", id, secret))
 
-		userID := uuid.New()
-		username, err := cryptorand.String(8)
-		require.NoError(t, err)
-
-		user, err := db.InsertUser(r.Context(), database.InsertUserParams{
-			ID:             userID,
-			Email:          "testaccount@coder.com",
-			HashedPassword: hashed[:],
-			Username:       username,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
-			LoginType:      database.LoginTypePassword,
+		user := dbgen.User(t, db, database.User{
+			ID: uuid.New(),
 		})
-		require.NoError(t, err)
-		_, err = db.InsertAPIKey(r.Context(), database.InsertAPIKeyParams{
-			ID:           id,
-			UserID:       user.ID,
-			HashedSecret: hashed[:],
-			LastUsed:     database.Now(),
-			ExpiresAt:    database.Now().Add(time.Minute),
-			LoginType:    database.LoginTypePassword,
-			Scope:        database.APIKeyScopeAll,
+		_, token := dbgen.APIKey(t, db, database.APIKey{
+			UserID: user.ID,
 		})
-		require.NoError(t, err)
+		r.Header.Set(codersdk.SessionTokenHeader, token)
 		r = r.WithContext(context.WithValue(r.Context(), chi.RouteCtxKey, chi.NewRouteContext()))
 		return r, user
 	}
@@ -168,20 +145,11 @@ func TestOrganizationParam(t *testing.T) {
 			r, user = setupAuthentication(db)
 			rtr     = chi.NewRouter()
 		)
-		organization, err := db.InsertOrganization(r.Context(), database.InsertOrganizationParams{
-			ID:        uuid.New(),
-			Name:      "test",
-			CreatedAt: database.Now(),
-			UpdatedAt: database.Now(),
-		})
-		require.NoError(t, err)
-		_, err = db.InsertOrganizationMember(r.Context(), database.InsertOrganizationMemberParams{
+		organization := dbgen.Organization(t, db, database.Organization{})
+		_ = dbgen.OrganizationMember(t, db, database.OrganizationMember{
 			OrganizationID: organization.ID,
 			UserID:         user.ID,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
 		})
-		require.NoError(t, err)
 		chi.RouteContext(r.Context()).URLParams.Add("organization", organization.ID.String())
 		chi.RouteContext(r.Context()).URLParams.Add("user", user.ID.String())
 		rtr.Use(

coderd/httpmw/templateparam_test.go

@@ -2,12 +2,9 @@ package httpmw_test
 
 import (
 	"context"
-	"crypto/sha256"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-	"time"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/google/uuid"
@@ -15,9 +12,9 @@ import (
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbfake"
+	"github.com/coder/coder/coderd/database/dbgen"
 	"github.com/coder/coder/coderd/httpmw"
 	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/cryptorand"
 )
 
 func TestTemplateParam(t *testing.T) {
@@ -25,54 +22,19 @@ func TestTemplateParam(t *testing.T) {
 
 	setupAuthentication := func(db database.Store) (*http.Request, database.Organization) {
 		var (
-			id, secret = randomAPIKeyParts()
-			hashed     = sha256.Sum256([]byte(secret))
+			user     = dbgen.User(t, db, database.User{})
+			_, token = dbgen.APIKey(t, db, database.APIKey{
+				UserID: user.ID,
+			})
+			organization = dbgen.Organization(t, db, database.Organization{})
+			_            = dbgen.OrganizationMember(t, db, database.OrganizationMember{
+				UserID:         user.ID,
+				OrganizationID: organization.ID,
+			})
 		)
+
 		r := httptest.NewRequest("GET", "/", nil)
-		r.Header.Set(codersdk.SessionTokenHeader, fmt.Sprintf("%s-%s", id, secret))
-
-		userID := uuid.New()
-		username, err := cryptorand.String(8)
-		require.NoError(t, err)
-		user, err := db.InsertUser(r.Context(), database.InsertUserParams{
-			ID:             userID,
-			Email:          "testaccount@coder.com",
-			HashedPassword: hashed[:],
-			Username:       username,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
-			LoginType:      database.LoginTypePassword,
-		})
-		require.NoError(t, err)
-
-		_, err = db.InsertAPIKey(r.Context(), database.InsertAPIKeyParams{
-			ID:           id,
-			UserID:       user.ID,
-			HashedSecret: hashed[:],
-			LastUsed:     database.Now(),
-			ExpiresAt:    database.Now().Add(time.Minute),
-			LoginType:    database.LoginTypePassword,
-			Scope:        database.APIKeyScopeAll,
-		})
-		require.NoError(t, err)
-
-		orgID := uuid.New()
-		organization, err := db.InsertOrganization(r.Context(), database.InsertOrganizationParams{
-			ID:          orgID,
-			Name:        "banana",
-			Description: "wowie",
-			CreatedAt:   database.Now(),
-			UpdatedAt:   database.Now(),
-		})
-		require.NoError(t, err)
-
-		_, err = db.InsertOrganizationMember(r.Context(), database.InsertOrganizationMemberParams{
-			OrganizationID: orgID,
-			UserID:         user.ID,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
-		})
-		require.NoError(t, err)
+		r.Header.Set(codersdk.SessionTokenHeader, token)
 
 		ctx := chi.NewRouteContext()
 		r = r.WithContext(context.WithValue(r.Context(), chi.RouteCtxKey, ctx))
@@ -146,13 +108,11 @@ func TestTemplateParam(t *testing.T) {
 		})
 
 		r, org := setupAuthentication(db)
-		template, err := db.InsertTemplate(context.Background(), database.InsertTemplateParams{
-			ID:             uuid.New(),
+		template := dbgen.Template(t, db, database.Template{
 			OrganizationID: org.ID,
-			Name:           "moo",
 			Provisioner:    database.ProvisionerTypeEcho,
 		})
-		require.NoError(t, err)
+
 		chi.RouteContext(r.Context()).URLParams.Add("template", template.ID.String())
 		rw := httptest.NewRecorder()
 		rtr.ServeHTTP(rw, r)

coderd/httpmw/templateversionparam_test.go

@@ -2,12 +2,9 @@ package httpmw_test
 
 import (
 	"context"
-	"crypto/sha256"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-	"time"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/google/uuid"
@@ -15,72 +12,31 @@ import (
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbfake"
+	"github.com/coder/coder/coderd/database/dbgen"
 	"github.com/coder/coder/coderd/httpmw"
 	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/cryptorand"
 )
 
 func TestTemplateVersionParam(t *testing.T) {
 	t.Parallel()
 
 	setupAuthentication := func(db database.Store) (*http.Request, database.Template) {
-		var (
-			id, secret = randomAPIKeyParts()
-			hashed     = sha256.Sum256([]byte(secret))
-		)
-		r := httptest.NewRequest("GET", "/", nil)
-		r.Header.Set(codersdk.SessionTokenHeader, fmt.Sprintf("%s-%s", id, secret))
-
-		userID := uuid.New()
-		username, err := cryptorand.String(8)
-		require.NoError(t, err)
-		user, err := db.InsertUser(r.Context(), database.InsertUserParams{
-			ID:             userID,
-			Email:          "testaccount@coder.com",
-			HashedPassword: hashed[:],
-			Username:       username,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
-			LoginType:      database.LoginTypePassword,
+		user := dbgen.User(t, db, database.User{})
+		_, token := dbgen.APIKey(t, db, database.APIKey{
+			UserID: user.ID,
 		})
-		require.NoError(t, err)
-
-		_, err = db.InsertAPIKey(r.Context(), database.InsertAPIKeyParams{
-			ID:           id,
-			UserID:       user.ID,
-			HashedSecret: hashed[:],
-			LastUsed:     database.Now(),
-			ExpiresAt:    database.Now().Add(time.Minute),
-			LoginType:    database.LoginTypePassword,
-			Scope:        database.APIKeyScopeAll,
-		})
-		require.NoError(t, err)
-
-		orgID := uuid.New()
-		organization, err := db.InsertOrganization(r.Context(), database.InsertOrganizationParams{
-			ID:          orgID,
-			Name:        "banana",
-			Description: "wowie",
-			CreatedAt:   database.Now(),
-			UpdatedAt:   database.Now(),
-		})
-		require.NoError(t, err)
-
-		_, err = db.InsertOrganizationMember(r.Context(), database.InsertOrganizationMemberParams{
-			OrganizationID: orgID,
+		organization := dbgen.Organization(t, db, database.Organization{})
+		_ = dbgen.OrganizationMember(t, db, database.OrganizationMember{
 			UserID:         user.ID,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
-		})
-		require.NoError(t, err)
-
-		template, err := db.InsertTemplate(context.Background(), database.InsertTemplateParams{
-			ID:             uuid.New(),
 			OrganizationID: organization.ID,
-			Name:           "moo",
+		})
+		template := dbgen.Template(t, db, database.Template{
+			OrganizationID: organization.ID,
 			Provisioner:    database.ProvisionerTypeEcho,
 		})
-		require.NoError(t, err)
+
+		r := httptest.NewRequest("GET", "/", nil)
+		r.Header.Set(codersdk.SessionTokenHeader, token)
 
 		ctx := chi.NewRouteContext()
 		ctx.URLParams.Add("organization", organization.Name)
@@ -139,12 +95,9 @@ func TestTemplateVersionParam(t *testing.T) {
 		})
 
 		r, template := setupAuthentication(db)
-		templateVersion, err := db.InsertTemplateVersion(context.Background(), database.InsertTemplateVersionParams{
-			ID:             uuid.New(),
+		templateVersion := dbgen.TemplateVersion(t, db, database.TemplateVersion{
 			OrganizationID: template.OrganizationID,
-			Name:           "moo",
 		})
-		require.NoError(t, err)
 		chi.RouteContext(r.Context()).URLParams.Add("templateversion", templateVersion.ID.String())
 		rw := httptest.NewRecorder()
 		rtr.ServeHTTP(rw, r)

coderd/httpmw/userparam_test.go

@@ -2,19 +2,16 @@ package httpmw_test
 
 import (
 	"context"
-	"crypto/sha256"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-	"time"
 
 	"github.com/go-chi/chi/v5"
-	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbfake"
+	"github.com/coder/coder/coderd/database/dbgen"
 	"github.com/coder/coder/coderd/httpmw"
 	"github.com/coder/coder/codersdk"
 )
@@ -23,32 +20,15 @@ func TestUserParam(t *testing.T) {
 	t.Parallel()
 	setup := func(t *testing.T) (database.Store, *httptest.ResponseRecorder, *http.Request) {
 		var (
-			db         = dbfake.New()
-			id, secret = randomAPIKeyParts()
-			hashed     = sha256.Sum256([]byte(secret))
-			r          = httptest.NewRequest("GET", "/", nil)
-			rw         = httptest.NewRecorder()
+			db = dbfake.New()
+			r  = httptest.NewRequest("GET", "/", nil)
+			rw = httptest.NewRecorder()
 		)
-		r.Header.Set(codersdk.SessionTokenHeader, fmt.Sprintf("%s-%s", id, secret))
-
-		user, err := db.InsertUser(r.Context(), database.InsertUserParams{
-			ID:        uuid.New(),
-			Email:     "admin@email.com",
-			Username:  "admin",
-			LoginType: database.LoginTypePassword,
+		user := dbgen.User(t, db, database.User{})
+		_, token := dbgen.APIKey(t, db, database.APIKey{
+			UserID: user.ID,
 		})
-		require.NoError(t, err)
-
-		_, err = db.InsertAPIKey(r.Context(), database.InsertAPIKeyParams{
-			ID:           id,
-			UserID:       user.ID,
-			HashedSecret: hashed[:],
-			LastUsed:     database.Now(),
-			ExpiresAt:    database.Now().Add(time.Minute),
-			LoginType:    database.LoginTypePassword,
-			Scope:        database.APIKeyScopeAll,
-		})
-		require.NoError(t, err)
+		r.Header.Set(codersdk.SessionTokenHeader, token)
 
 		return db, rw, r
 	}

coderd/httpmw/workspaceagent_test.go

@@ -1,7 +1,6 @@
 package httpmw_test
 
 import (
-	"context"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -12,6 +11,7 @@ import (
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbfake"
+	"github.com/coder/coder/coderd/database/dbgen"
 	"github.com/coder/coder/coderd/httpmw"
 	"github.com/coder/coder/codersdk"
 )
@@ -55,12 +55,9 @@ func TestWorkspaceAgent(t *testing.T) {
 			rw.WriteHeader(http.StatusOK)
 		})
 		r, token := setup(db)
-		_, err := db.InsertWorkspaceAgent(context.Background(), database.InsertWorkspaceAgentParams{
-			ID:        uuid.New(),
+		_ = dbgen.WorkspaceAgent(t, db, database.WorkspaceAgent{
 			AuthToken: token,
 		})
-		require.NoError(t, err)
-		require.NoError(t, err)
 		rw := httptest.NewRecorder()
 		rtr.ServeHTTP(rw, r)
 

coderd/httpmw/workspaceagentparam_test.go

@@ -2,12 +2,9 @@ package httpmw_test
 
 import (
 	"context"
-	"crypto/sha256"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-	"time"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/google/uuid"
@@ -15,9 +12,9 @@ import (
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbfake"
+	"github.com/coder/coder/coderd/database/dbgen"
 	"github.com/coder/coder/coderd/httpmw"
 	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/cryptorand"
 )
 
 func TestWorkspaceAgentParam(t *testing.T) {
@@ -25,77 +22,38 @@ func TestWorkspaceAgentParam(t *testing.T) {
 
 	setupAuthentication := func(db database.Store) (*http.Request, database.WorkspaceAgent) {
 		var (
-			id, secret = randomAPIKeyParts()
-			hashed     = sha256.Sum256([]byte(secret))
+			user     = dbgen.User(t, db, database.User{})
+			_, token = dbgen.APIKey(t, db, database.APIKey{
+				UserID: user.ID,
+			})
+			workspace = dbgen.Workspace(t, db, database.Workspace{
+				OwnerID: user.ID,
+			})
+			build = dbgen.WorkspaceBuild(t, db, database.WorkspaceBuild{
+				WorkspaceID: workspace.ID,
+				Transition:  database.WorkspaceTransitionStart,
+				Reason:      database.BuildReasonInitiator,
+			})
+			job = dbgen.ProvisionerJob(t, db, database.ProvisionerJob{
+				ID:            build.JobID,
+				Type:          database.ProvisionerJobTypeWorkspaceBuild,
+				Provisioner:   database.ProvisionerTypeEcho,
+				StorageMethod: database.ProvisionerStorageMethodFile,
+			})
+			resource = dbgen.WorkspaceResource(t, db, database.WorkspaceResource{
+				JobID:      job.ID,
+				Transition: database.WorkspaceTransitionStart,
+			})
+			agent = dbgen.WorkspaceAgent(t, db, database.WorkspaceAgent{
+				ResourceID: resource.ID,
+			})
 		)
+
 		r := httptest.NewRequest("GET", "/", nil)
-		r.Header.Set(codersdk.SessionTokenHeader, fmt.Sprintf("%s-%s", id, secret))
-
-		userID := uuid.New()
-		username, err := cryptorand.String(8)
-		require.NoError(t, err)
-		user, err := db.InsertUser(r.Context(), database.InsertUserParams{
-			ID:             userID,
-			Email:          "testaccount@coder.com",
-			HashedPassword: hashed[:],
-			Username:       username,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
-			LoginType:      database.LoginTypePassword,
-		})
-		require.NoError(t, err)
-
-		_, err = db.InsertAPIKey(r.Context(), database.InsertAPIKeyParams{
-			ID:           id,
-			UserID:       user.ID,
-			HashedSecret: hashed[:],
-			LastUsed:     database.Now(),
-			ExpiresAt:    database.Now().Add(time.Minute),
-			LoginType:    database.LoginTypePassword,
-			Scope:        database.APIKeyScopeAll,
-		})
-		require.NoError(t, err)
-
-		workspace, err := db.InsertWorkspace(context.Background(), database.InsertWorkspaceParams{
-			ID:         uuid.New(),
-			TemplateID: uuid.New(),
-			OwnerID:    user.ID,
-			Name:       "potato",
-		})
-		require.NoError(t, err)
-
-		build, err := db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
-			ID:          uuid.New(),
-			WorkspaceID: workspace.ID,
-			JobID:       uuid.New(),
-			Transition:  database.WorkspaceTransitionStart,
-			Reason:      database.BuildReasonInitiator,
-		})
-		require.NoError(t, err)
-
-		job, err := db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
-			ID:            build.JobID,
-			Type:          database.ProvisionerJobTypeWorkspaceBuild,
-			Provisioner:   database.ProvisionerTypeEcho,
-			StorageMethod: database.ProvisionerStorageMethodFile,
-		})
-		require.NoError(t, err)
-
-		resource, err := db.InsertWorkspaceResource(context.Background(), database.InsertWorkspaceResourceParams{
-			ID:         uuid.New(),
-			JobID:      job.ID,
-			Transition: database.WorkspaceTransitionStart,
-		})
-		require.NoError(t, err)
-
-		agent, err := db.InsertWorkspaceAgent(context.Background(), database.InsertWorkspaceAgentParams{
-			ID:         uuid.New(),
-			ResourceID: resource.ID,
-		})
-		require.NoError(t, err)
+		r.Header.Set(codersdk.SessionTokenHeader, token)
 
 		ctx := chi.NewRouteContext()
-		ctx.URLParams.Add("user", userID.String())
+		ctx.URLParams.Add("user", user.ID.String())
 		ctx.URLParams.Add("workspaceagent", agent.ID.String())
 		r = r.WithContext(context.WithValue(r.Context(), chi.RouteCtxKey, ctx))
 		return r, agent

coderd/httpmw/workspacebuildparam_test.go

@@ -2,12 +2,9 @@ package httpmw_test
 
 import (
 	"context"
-	"crypto/sha256"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-	"time"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/google/uuid"
@@ -15,9 +12,9 @@ import (
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbfake"
+	"github.com/coder/coder/coderd/database/dbgen"
 	"github.com/coder/coder/coderd/httpmw"
 	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/cryptorand"
 )
 
 func TestWorkspaceBuildParam(t *testing.T) {
@@ -25,47 +22,20 @@ func TestWorkspaceBuildParam(t *testing.T) {
 
 	setupAuthentication := func(db database.Store) (*http.Request, database.Workspace) {
 		var (
-			id, secret = randomAPIKeyParts()
-			hashed     = sha256.Sum256([]byte(secret))
+			user     = dbgen.User(t, db, database.User{})
+			_, token = dbgen.APIKey(t, db, database.APIKey{
+				UserID: user.ID,
+			})
+			workspace = dbgen.Workspace(t, db, database.Workspace{
+				OwnerID: user.ID,
+			})
 		)
+
 		r := httptest.NewRequest("GET", "/", nil)
-		r.Header.Set(codersdk.SessionTokenHeader, fmt.Sprintf("%s-%s", id, secret))
-
-		userID := uuid.New()
-		username, err := cryptorand.String(8)
-		require.NoError(t, err)
-		user, err := db.InsertUser(r.Context(), database.InsertUserParams{
-			ID:             userID,
-			Email:          "testaccount@coder.com",
-			HashedPassword: hashed[:],
-			Username:       username,
-			CreatedAt:      database.Now(),
-			UpdatedAt:      database.Now(),
-			LoginType:      database.LoginTypePassword,
-		})
-		require.NoError(t, err)
-
-		_, err = db.InsertAPIKey(r.Context(), database.InsertAPIKeyParams{
-			ID:           id,
-			UserID:       user.ID,
-			HashedSecret: hashed[:],
-			LastUsed:     database.Now(),
-			ExpiresAt:    database.Now().Add(time.Minute),
-			LoginType:    database.LoginTypePassword,
-			Scope:        database.APIKeyScopeAll,
-		})
-		require.NoError(t, err)
-
-		workspace, err := db.InsertWorkspace(context.Background(), database.InsertWorkspaceParams{
-			ID:         uuid.New(),
-			TemplateID: uuid.New(),
-			OwnerID:    user.ID,
-			Name:       "potato",
-		})
-		require.NoError(t, err)
+		r.Header.Set(codersdk.SessionTokenHeader, token)
 
 		ctx := chi.NewRouteContext()
-		ctx.URLParams.Add("user", userID.String())
+		ctx.URLParams.Add("user", user.ID.String())
 		ctx.URLParams.Add("workspace", workspace.Name)
 		r = r.WithContext(context.WithValue(r.Context(), chi.RouteCtxKey, ctx))
 		return r, workspace
@@ -121,13 +91,12 @@ func TestWorkspaceBuildParam(t *testing.T) {
 		})
 
 		r, workspace := setupAuthentication(db)
-		workspaceBuild, err := db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
-			ID:          uuid.New(),
-			WorkspaceID: workspace.ID,
+		workspaceBuild := dbgen.WorkspaceBuild(t, db, database.WorkspaceBuild{
 			Transition:  database.WorkspaceTransitionStart,
 			Reason:      database.BuildReasonInitiator,
+			WorkspaceID: workspace.ID,
 		})
-		require.NoError(t, err)
+
 		chi.RouteContext(r.Context()).URLParams.Add("workspacebuild", workspaceBuild.ID.String())
 		rw := httptest.NewRecorder()
 		rtr.ServeHTTP(rw, r)

coderd/httpmw/workspaceparam_test.go

@@ -10,14 +10,14 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/go-chi/chi/v5"
 	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/coderd/database/dbfake"
+	"github.com/coder/coder/coderd/database/dbgen"
 	"github.com/coder/coder/coderd/httpmw"
 	"github.com/coder/coder/codersdk"
 	"github.com/coder/coder/cryptorand"
@@ -340,79 +340,44 @@ type setupConfig struct {
 func setupWorkspaceWithAgents(t testing.TB, cfg setupConfig) (database.Store, *http.Request) {
 	t.Helper()
 	db := dbfake.New()
+
 	var (
-		id, secret = randomAPIKeyParts()
-		hashed     = sha256.Sum256([]byte(secret))
+		user     = dbgen.User(t, db, database.User{})
+		_, token = dbgen.APIKey(t, db, database.APIKey{
+			UserID: user.ID,
+		})
+		workspace = dbgen.Workspace(t, db, database.Workspace{
+			OwnerID: user.ID,
+			Name:    cfg.WorkspaceName,
+		})
+		build = dbgen.WorkspaceBuild(t, db, database.WorkspaceBuild{
+			WorkspaceID: workspace.ID,
+			Transition:  database.WorkspaceTransitionStart,
+			Reason:      database.BuildReasonInitiator,
+		})
+		job = dbgen.ProvisionerJob(t, db, database.ProvisionerJob{
+			ID:            build.JobID,
+			Type:          database.ProvisionerJobTypeWorkspaceBuild,
+			Provisioner:   database.ProvisionerTypeEcho,
+			StorageMethod: database.ProvisionerStorageMethodFile,
+		})
 	)
+
 	r := httptest.NewRequest("GET", "/", nil)
-	r.Header.Set(codersdk.SessionTokenHeader, fmt.Sprintf("%s-%s", id, secret))
-
-	userID := uuid.New()
-	username, err := cryptorand.String(8)
-	require.NoError(t, err)
-	user, err := db.InsertUser(r.Context(), database.InsertUserParams{
-		ID:             userID,
-		Email:          "testaccount@coder.com",
-		HashedPassword: hashed[:],
-		Username:       username,
-		CreatedAt:      database.Now(),
-		UpdatedAt:      database.Now(),
-		LoginType:      database.LoginTypePassword,
-	})
-	require.NoError(t, err)
-
-	_, err = db.InsertAPIKey(r.Context(), database.InsertAPIKeyParams{
-		ID:           id,
-		UserID:       user.ID,
-		HashedSecret: hashed[:],
-		LastUsed:     database.Now(),
-		ExpiresAt:    database.Now().Add(time.Minute),
-		LoginType:    database.LoginTypePassword,
-		Scope:        database.APIKeyScopeAll,
-	})
-	require.NoError(t, err)
-
-	workspace, err := db.InsertWorkspace(context.Background(), database.InsertWorkspaceParams{
-		ID:         uuid.New(),
-		TemplateID: uuid.New(),
-		OwnerID:    user.ID,
-		Name:       cfg.WorkspaceName,
-	})
-	require.NoError(t, err)
-
-	build, err := db.InsertWorkspaceBuild(context.Background(), database.InsertWorkspaceBuildParams{
-		ID:          uuid.New(),
-		WorkspaceID: workspace.ID,
-		JobID:       uuid.New(),
-		Transition:  database.WorkspaceTransitionStart,
-		Reason:      database.BuildReasonInitiator,
-	})
-	require.NoError(t, err)
-
-	job, err := db.InsertProvisionerJob(context.Background(), database.InsertProvisionerJobParams{
-		ID:            build.JobID,
-		Type:          database.ProvisionerJobTypeWorkspaceBuild,
-		Provisioner:   database.ProvisionerTypeEcho,
-		StorageMethod: database.ProvisionerStorageMethodFile,
-	})
-	require.NoError(t, err)
+	r.Header.Set(codersdk.SessionTokenHeader, token)
 
 	for resourceName, agentNames := range cfg.Agents {
-		resource, err := db.InsertWorkspaceResource(context.Background(), database.InsertWorkspaceResourceParams{
-			ID:         uuid.New(),
+		resource := dbgen.WorkspaceResource(t, db, database.WorkspaceResource{
 			JobID:      job.ID,
 			Name:       resourceName,
 			Transition: database.WorkspaceTransitionStart,
 		})
-		require.NoError(t, err)
 
 		for _, name := range agentNames {
-			_, err = db.InsertWorkspaceAgent(context.Background(), database.InsertWorkspaceAgentParams{
-				ID:         uuid.New(),
+			_ = dbgen.WorkspaceAgent(t, db, database.WorkspaceAgent{
 				ResourceID: resource.ID,
 				Name:       name,
 			})
-			require.NoError(t, err)
 		}
 	}