Standardize tests a bit more

coder · kylecarbs · Feb 6, 2022 · Feb 5, 2022 · Feb 5, 2022 · Feb 5, 2022
commit 9e04a0ec43102bee56cb55c2bd14a6377147ef9d
diff --git a/coderd/coderdtest/coderdtest.go b/coderd/coderdtest/coderdtest.go
@@ -7,16 +7,17 @@ import (
 	"net/http/httptest"
 	"net/url"
 	"os"
+	"strings"
 	"testing"
 	"time"
 
+	"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,6 +27,48 @@ import (
 	"github.com/coder/coder/provisionersdk/proto"
 )
 
+// 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)
+
+		pubsub, err = database.NewPubsub(context.Background(), sqlDB, connectionURL)
+		require.NoError(t, err)
+		t.Cleanup(func() {
+			_ = pubsub.Close()
+		})
+	}
+
+	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)
+	t.Cleanup(srv.Close)
+
+	return Server{
+		Client: codersdk.New(serverURL),
+		URL:    serverURL,
+	}
+}
+
 // Server represents a test instance of coderd.
 // The database is intentionally omitted from
 // this struct to promote data being exposed via
@@ -35,38 +78,32 @@ type Server struct {
 	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)
-
+// NewInitialUser creates a user with preset credentials and authenticates
+// with the passed in codersdk client.
+func NewInitialUser(t *testing.T, client *codersdk.Client) coderd.CreateInitialUserRequest {
 	req := coderd.CreateInitialUserRequest{
 		Email:        "testuser@coder.com",
-		Username:     username,
-		Password:     password,
-		Organization: organization,
+		Username:     "testuser",
+		Password:     "testpass",
+		Organization: "testorg",
 	}
-	_, err = s.Client.CreateInitialUser(context.Background(), req)
+	_, err := client.CreateInitialUser(context.Background(), req)
 	require.NoError(t, err)
 
-	login, err := s.Client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
-		Email:    "testuser@coder.com",
-		Password: password,
+	login, err := client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
+		Email:    req.Email,
+		Password: req.Password,
 	})
 	require.NoError(t, err)
-	err = s.Client.SetSessionToken(login.SessionToken)
+	err = client.SetSessionToken(login.SessionToken)
 	require.NoError(t, err)
 	return req
 }
 
-// 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 +118,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 +133,42 @@ 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)
-
-		pubsub, err = database.NewPubsub(context.Background(), sqlDB, connectionURL)
-		require.NoError(t, err)
-		t.Cleanup(func() {
-			_ = pubsub.Close()
-		})
-	}
+// NewProject creates a project with the "echo" provisioner for
+// compatibility with testing. The name assigned is randomly generated.
+func NewProject(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
+}
 
-	handler := coderd.New(&coderd.Options{
-		Logger:   slogtest.Make(t, nil).Leveled(slog.LevelDebug),
-		Database: db,
-		Pubsub:   pubsub,
+// NewProjectVersion creates a project version for the "echo" provisioner
+// for compatibility with testing.
+func NewProjectVersion(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,
 	})
-	srv := httptest.NewServer(handler)
-	serverURL, err := url.Parse(srv.URL)
 	require.NoError(t, err)
-	t.Cleanup(srv.Close)
+	return version
+}
 
-	return Server{
-		Client: codersdk.New(serverURL),
-		URL:    serverURL,
-	}
+// 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)
+		return projectVersion.Import.Status.Completed()
+	}, 3*time.Second, 50*time.Millisecond)
+	return projectVersion
+}
+
+func randomUsername() string {
+	return strings.ReplaceAll(namesgenerator.GetRandomName(0), "_", "-")
 }
diff --git a/coderd/coderdtest/coderdtest_test.go b/coderd/coderdtest/coderdtest_test.go
@@ -15,6 +15,6 @@ func TestMain(m *testing.M) {
 func TestNew(t *testing.T) {
 	t.Parallel()
 	server := coderdtest.New(t)
-	_ = server.RandomInitialUser(t)
-	_ = server.AddProvisionerd(t)
+	_ = coderdtest.NewInitialUser(t, server.Client)
+	_ = coderdtest.NewProvisionerDaemon(t, server.Client)
 }
diff --git a/coderd/projects.go b/coderd/projects.go
@@ -124,32 +124,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) {