coder · kylecarbs · Feb 6, 2022 · Feb 5, 2022 · Feb 5, 2022 · Feb 5, 2022
diff --git a/.golangci.yml b/.golangci.yml
@@ -100,6 +100,10 @@ linters-settings:
       # - whyNoLint
       # - wrapperFunc
       # - yodaStyleExpr
+    settings:
+      ruleguard:
+        failOn: all
+        rules: rules.go
 
   goimports:
     local-prefixes: coder.com,cdr.dev,go.coder.com,github.com/cdr,github.com/coder

diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -86,7 +86,6 @@ func New(options *Options) http.Handler {
 			r.Get("/", api.workspaces)
 			r.Route("/{user}", func(r chi.Router) {
 				r.Use(httpmw.ExtractUserParam(options.Database))
-				r.Get("/", api.workspaces)
 				r.Post("/", api.postWorkspaceByUser)
 				r.Route("/{workspace}", func(r chi.Router) {
 					r.Use(httpmw.ExtractWorkspaceParam(options.Database))

diff --git a/coderd/coderdtest/coderdtest.go b/coderd/coderdtest/coderdtest.go
@@ -7,16 +7,18 @@ import (
 	"net/http/httptest"
 	"net/url"
 	"os"
+	"strings"
 	"testing"
 	"time"
 
+	"github.com/google/uuid"
+	"github.com/moby/moby/pkg/namesgenerator"
 	"github.com/stretchr/testify/require"
 
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/coderd"
 	"github.com/coder/coder/codersdk"
-	"github.com/coder/coder/cryptorand"
 	"github.com/coder/coder/database"
 	"github.com/coder/coder/database/databasefake"
 	"github.com/coder/coder/database/postgres"
@@ -26,47 +28,49 @@ import (
 	"github.com/coder/coder/provisionersdk/proto"
 )
 
-// Server represents a test instance of coderd.
-// The database is intentionally omitted from
-// this struct to promote data being exposed via
-// the API.
-type Server struct {
-	Client *codersdk.Client
-	URL    *url.URL
-}
-
-// RandomInitialUser generates a random initial user and authenticates
-// it with the client on the Server struct.
-func (s *Server) RandomInitialUser(t *testing.T) coderd.CreateInitialUserRequest {
-	username, err := cryptorand.String(12)
-	require.NoError(t, err)
-	password, err := cryptorand.String(12)
-	require.NoError(t, err)
-	organization, err := cryptorand.String(12)
-	require.NoError(t, err)
+// New constructs a new coderd test instance. This returned Server
+// should contain no side-effects.
+func New(t *testing.T) *codersdk.Client {
+	// This can be hotswapped for a live database instance.
+	db := databasefake.New()
+	pubsub := database.NewPubsubInMemory()
+	if os.Getenv("DB") != "" {
+		connectionURL, close, err := postgres.Open()
+		require.NoError(t, err)
+		t.Cleanup(close)
+		sqlDB, err := sql.Open("postgres", connectionURL)
+		require.NoError(t, err)
+		t.Cleanup(func() {
+			_ = sqlDB.Close()
+		})
+		err = database.Migrate(sqlDB)
+		require.NoError(t, err)
+		db = database.New(sqlDB)
 
-	req := coderd.CreateInitialUserRequest{
-		Email:        "testuser@coder.com",
-		Username:     username,
-		Password:     password,
-		Organization: organization,
+		pubsub, err = database.NewPubsub(context.Background(), sqlDB, connectionURL)
+		require.NoError(t, err)
+		t.Cleanup(func() {
+			_ = pubsub.Close()
+		})
 	}
-	_, err = s.Client.CreateInitialUser(context.Background(), req)
-	require.NoError(t, err)
 
-	login, err := s.Client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
-		Email:    "testuser@coder.com",
-		Password: password,
+	handler := coderd.New(&coderd.Options{
+		Logger:   slogtest.Make(t, nil).Leveled(slog.LevelDebug),
+		Database: db,
+		Pubsub:   pubsub,
 	})
+	srv := httptest.NewServer(handler)
+	serverURL, err := url.Parse(srv.URL)
 	require.NoError(t, err)
-	err = s.Client.SetSessionToken(login.SessionToken)
-	require.NoError(t, err)
-	return req
+	t.Cleanup(srv.Close)
+
+	return codersdk.New(serverURL)
 }
 
-// AddProvisionerd launches a new provisionerd instance with the
-// test provisioner registered.
-func (s *Server) AddProvisionerd(t *testing.T) io.Closer {
+// NewProvisionerDaemon launches a provisionerd instance configured to work
+// well with coderd testing. It registers the "echo" provisioner for
+// quick testing.
+func NewProvisionerDaemon(t *testing.T, client *codersdk.Client) io.Closer {
 	echoClient, echoServer := provisionersdk.TransportPipe()
 	ctx, cancelFunc := context.WithCancel(context.Background())
 	t.Cleanup(func() {
@@ -81,7 +85,7 @@ func (s *Server) AddProvisionerd(t *testing.T) io.Closer {
 		require.NoError(t, err)
 	}()
 
-	closer := provisionerd.New(s.Client.ProvisionerDaemonClient, &provisionerd.Options{
+	closer := provisionerd.New(client.ProvisionerDaemonClient, &provisionerd.Options{
 		Logger:         slogtest.Make(t, nil).Named("provisionerd").Leveled(slog.LevelDebug),
 		PollInterval:   50 * time.Millisecond,
 		UpdateInterval: 50 * time.Millisecond,
@@ -96,44 +100,87 @@ func (s *Server) AddProvisionerd(t *testing.T) io.Closer {
 	return closer
 }
 
-// New constructs a new coderd test instance. This returned Server
-// should contain no side-effects.
-func New(t *testing.T) Server {
-	// This can be hotswapped for a live database instance.
-	db := databasefake.New()
-	pubsub := database.NewPubsubInMemory()
-	if os.Getenv("DB") != "" {
-		connectionURL, close, err := postgres.Open()
-		require.NoError(t, err)
-		t.Cleanup(close)
-		sqlDB, err := sql.Open("postgres", connectionURL)
-		require.NoError(t, err)
-		t.Cleanup(func() {
-			_ = sqlDB.Close()
-		})
-		err = database.Migrate(sqlDB)
-		require.NoError(t, err)
-		db = database.New(sqlDB)
+// CreateInitialUser creates a user with preset credentials and authenticates
+// with the passed in codersdk client.
+func CreateInitialUser(t *testing.T, client *codersdk.Client) coderd.CreateInitialUserRequest {
+	req := coderd.CreateInitialUserRequest{
+		Email:        "testuser@coder.com",
+		Username:     "testuser",
+		Password:     "testpass",
+		Organization: "testorg",
+	}
+	_, err := client.CreateInitialUser(context.Background(), req)
+	require.NoError(t, err)
 
-		pubsub, err = database.NewPubsub(context.Background(), sqlDB, connectionURL)
+	login, err := client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
+		Email:    req.Email,
+		Password: req.Password,
+	})
+	require.NoError(t, err)
+	err = client.SetSessionToken(login.SessionToken)
+	require.NoError(t, err)
+	return req
+}
+
+// CreateProject creates a project with the "echo" provisioner for
+// compatibility with testing. The name assigned is randomly generated.
+func CreateProject(t *testing.T, client *codersdk.Client, organization string) coderd.Project {
+	project, err := client.CreateProject(context.Background(), organization, coderd.CreateProjectRequest{
+		Name:        randomUsername(),
+		Provisioner: database.ProvisionerTypeEcho,
+	})
+	require.NoError(t, err)
+	return project
+}
+
+// CreateProjectVersion creates a project version for the "echo" provisioner
+// for compatibility with testing.
+func CreateProjectVersion(t *testing.T, client *codersdk.Client, organization, project string, responses *echo.Responses) coderd.ProjectVersion {
+	data, err := echo.Tar(responses)
+	require.NoError(t, err)
+	version, err := client.CreateProjectVersion(context.Background(), organization, project, coderd.CreateProjectVersionRequest{
+		StorageMethod: database.ProjectStorageMethodInlineArchive,
+		StorageSource: data,
+	})
+	require.NoError(t, err)
+	return version
+}
+
+// AwaitProjectVersionImported awaits for the project import job to reach completed status.
+func AwaitProjectVersionImported(t *testing.T, client *codersdk.Client, organization, project, version string) coderd.ProjectVersion {
+	var projectVersion coderd.ProjectVersion
+	require.Eventually(t, func() bool {
+		var err error
+		projectVersion, err = client.ProjectVersion(context.Background(), organization, project, version)
 		require.NoError(t, err)
-		t.Cleanup(func() {
-			_ = pubsub.Close()
-		})
-	}
+		return projectVersion.Import.Status.Completed()
+	}, 3*time.Second, 25*time.Millisecond)
+	return projectVersion
+}
 
-	handler := coderd.New(&coderd.Options{
-		Logger:   slogtest.Make(t, nil).Leveled(slog.LevelDebug),
-		Database: db,
-		Pubsub:   pubsub,
+// CreateWorkspace creates a workspace for the user and project provided.
+// A random name is generated for it.
+func CreateWorkspace(t *testing.T, client *codersdk.Client, user string, projectID uuid.UUID) coderd.Workspace {
+	workspace, err := client.CreateWorkspace(context.Background(), user, coderd.CreateWorkspaceRequest{
+		ProjectID: projectID,
+		Name:      randomUsername(),
 	})
-	srv := httptest.NewServer(handler)
-	serverURL, err := url.Parse(srv.URL)
 	require.NoError(t, err)
-	t.Cleanup(srv.Close)
+	return workspace
+}
 
-	return Server{
-		Client: codersdk.New(serverURL),
-		URL:    serverURL,
-	}
+// AwaitWorkspaceHistoryProvisioned awaits for the workspace provision job to reach completed status.
+func AwaitWorkspaceHistoryProvisioned(t *testing.T, client *codersdk.Client, user, workspace, history string) coderd.WorkspaceHistory {
+	var workspaceHistory coderd.WorkspaceHistory
+	require.Eventually(t, func() bool {
+		var err error
+		workspaceHistory, err = client.WorkspaceHistory(context.Background(), user, workspace, history)
+		require.NoError(t, err)
+		return workspaceHistory.Provision.Status.Completed()
+	}, 3*time.Second, 25*time.Millisecond)
+	return workspaceHistory
+}
+
+func randomUsername() string {
+	return strings.ReplaceAll(namesgenerator.GetRandomName(0), "_", "-")
 }
diff --git a/coderd/coderdtest/coderdtest_test.go b/coderd/coderdtest/coderdtest_test.go
@@ -1,11 +1,16 @@
 package coderdtest_test
 
 import (
+	"context"
 	"testing"
 
 	"go.uber.org/goleak"
 
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/coderd"
 	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/database"
 )
 
 func TestMain(m *testing.M) {
@@ -14,7 +19,18 @@ func TestMain(m *testing.M) {
 
 func TestNew(t *testing.T) {
 	t.Parallel()
-	server := coderdtest.New(t)
-	_ = server.RandomInitialUser(t)
-	_ = server.AddProvisionerd(t)
+	client := coderdtest.New(t)
+	user := coderdtest.CreateInitialUser(t, client)
+	closer := coderdtest.NewProvisionerDaemon(t, client)
+	project := coderdtest.CreateProject(t, client, user.Organization)
+	version := coderdtest.CreateProjectVersion(t, client, user.Organization, project.Name, nil)
+	coderdtest.AwaitProjectVersionImported(t, client, user.Organization, project.Name, version.Name)
+	workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
+	history, err := client.CreateWorkspaceHistory(context.Background(), "me", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
+		ProjectVersionID: version.ID,
+		Transition:       database.WorkspaceTransitionCreate,
+	})
+	require.NoError(t, err)
+	coderdtest.AwaitWorkspaceHistoryProvisioned(t, client, "me", workspace.Name, history.Name)
+	closer.Close()
 }
diff --git a/coderd/projects.go b/coderd/projects.go
@@ -49,6 +49,9 @@ func (api *api) projects(rw http.ResponseWriter, r *http.Request) {
 		})
 		return
 	}
+	if projects == nil {
+		projects = []database.Project{}
+	}
 	render.Status(r, http.StatusOK)
 	render.JSON(rw, r, projects)
 }
@@ -66,6 +69,9 @@ func (api *api) projectsByOrganization(rw http.ResponseWriter, r *http.Request)
 		})
 		return
 	}
+	if projects == nil {
+		projects = []database.Project{}
+	}
 	render.Status(r, http.StatusOK)
 	render.JSON(rw, r, projects)
 }
@@ -124,32 +130,6 @@ func (*api) projectByOrganization(rw http.ResponseWriter, r *http.Request) {
 	render.JSON(rw, r, project)
 }
 
-// Returns all workspaces for a specific project.
-func (api *api) workspacesByProject(rw http.ResponseWriter, r *http.Request) {
-	apiKey := httpmw.APIKey(r)
-	project := httpmw.ProjectParam(r)
-	workspaces, err := api.Database.GetWorkspacesByProjectAndUserID(r.Context(), database.GetWorkspacesByProjectAndUserIDParams{
-		OwnerID:   apiKey.UserID,
-		ProjectID: project.ID,
-	})
-	if errors.Is(err, sql.ErrNoRows) {
-		err = nil
-	}
-	if err != nil {
-		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
-			Message: fmt.Sprintf("get workspaces: %s", err),
-		})
-		return
-	}
-
-	apiWorkspaces := make([]Workspace, 0, len(workspaces))
-	for _, workspace := range workspaces {
-		apiWorkspaces = append(apiWorkspaces, convertWorkspace(workspace))
-	}
-	render.Status(r, http.StatusOK)
-	render.JSON(rw, r, apiWorkspaces)
-}
-
 // Creates parameters for a project.
 // This should validate the calling user has permissions!
 func (api *api) postParametersByProject(rw http.ResponseWriter, r *http.Request) {