package coderd_test

import (

"context"

"fmt"

"net/http"

"strings"

"testing"

"time"

"github.com/google/uuid"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

"cdr.dev/slog"

"cdr.dev/slog/sloggers/slogtest"

"github.com/coder/coder/agent"

"github.com/coder/coder/coderd/audit"

"github.com/coder/coder/coderd/autobuild/schedule"

"github.com/coder/coder/coderd/coderdtest"

"github.com/coder/coder/coderd/database"

"github.com/coder/coder/coderd/rbac"

"github.com/coder/coder/coderd/util/ptr"

"github.com/coder/coder/codersdk"

"github.com/coder/coder/codersdk/agentsdk"

"github.com/coder/coder/cryptorand"

"github.com/coder/coder/provisioner/echo"

"github.com/coder/coder/provisionersdk/proto"

"github.com/coder/coder/testutil"

)

func TestWorkspace(t *testing.T) {

t.Parallel()

t.Run("OK", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

ws, err := client.Workspace(ctx, workspace.ID)

require.NoError(t, err)

require.Equal(t, user.UserID, ws.LatestBuild.InitiatorID)

require.Equal(t, codersdk.BuildReasonInitiator, ws.LatestBuild.Reason)

})

t.Run("Deleted", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// Getting with deleted=true should still work.

_, err := client.DeletedWorkspace(ctx, workspace.ID)

require.NoError(t, err)

// Delete the workspace

build, err := client.CreateWorkspaceBuild(ctx, workspace.ID, codersdk.CreateWorkspaceBuildRequest{

Transition: codersdk.WorkspaceTransitionDelete,

})

require.NoError(t, err, "delete the workspace")

coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)

// Getting with deleted=true should work.

workspaceNew, err := client.DeletedWorkspace(ctx, workspace.ID)

require.NoError(t, err)

require.Equal(t, workspace.ID, workspaceNew.ID)

// Getting with deleted=false should not work.

_, err = client.Workspace(ctx, workspace.ID)

require.Error(t, err)

require.ErrorContains(t, err, "410") // gone

})

t.Run("Rename", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

ws1 := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

ws2 := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

coderdtest.AwaitWorkspaceBuildJob(t, client, ws1.LatestBuild.ID)

coderdtest.AwaitWorkspaceBuildJob(t, client, ws2.LatestBuild.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)

defer cancel()

want := ws1.Name + "-test"

err := client.UpdateWorkspace(ctx, ws1.ID, codersdk.UpdateWorkspaceRequest{

Name: want,

})

require.NoError(t, err, "workspace rename failed")

ws, err := client.Workspace(ctx, ws1.ID)

require.NoError(t, err)

require.Equal(t, want, ws.Name, "workspace name not updated")

err = client.UpdateWorkspace(ctx, ws1.ID, codersdk.UpdateWorkspaceRequest{

Name: ws2.Name,

})

require.Error(t, err, "workspace rename should have failed")

})

t.Run("TemplateProperties", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

const templateIcon = "/img/icon.svg"

const templateDisplayName = "This is template"

var templateAllowUserCancelWorkspaceJobs = false

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID, func(ctr *codersdk.CreateTemplateRequest) {

ctr.Icon = templateIcon

ctr.DisplayName = templateDisplayName

ctr.AllowUserCancelWorkspaceJobs = &templateAllowUserCancelWorkspaceJobs

})

require.NotEmpty(t, template.Name)

require.NotEmpty(t, template.DisplayName)

require.NotEmpty(t, template.Icon)

require.False(t, template.AllowUserCancelWorkspaceJobs)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

ws, err := client.Workspace(ctx, workspace.ID)

require.NoError(t, err)

assert.Equal(t, user.UserID, ws.LatestBuild.InitiatorID)

assert.Equal(t, codersdk.BuildReasonInitiator, ws.LatestBuild.Reason)

assert.Equal(t, template.Name, ws.TemplateName)

assert.Equal(t, templateIcon, ws.TemplateIcon)

assert.Equal(t, templateDisplayName, ws.TemplateDisplayName)

assert.Equal(t, templateAllowUserCancelWorkspaceJobs, ws.TemplateAllowUserCancelWorkspaceJobs)

})

}

func TestAdminViewAllWorkspaces(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

_, err := client.Workspace(ctx, workspace.ID)

require.NoError(t, err)

otherOrg, err := client.CreateOrganization(ctx, codersdk.CreateOrganizationRequest{

Name: "default-test",

})

require.NoError(t, err, "create other org")

// This other user is not in the first user's org. Since other is an admin, they can

// still see the "first" user's workspace.

otherOwner, _ := coderdtest.CreateAnotherUser(t, client, otherOrg.ID, rbac.RoleOwner())

otherWorkspaces, err := otherOwner.Workspaces(ctx, codersdk.WorkspaceFilter{})

require.NoError(t, err, "(other) fetch workspaces")

firstWorkspaces, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{})

require.NoError(t, err, "(first) fetch workspaces")

require.ElementsMatch(t, otherWorkspaces.Workspaces, firstWorkspaces.Workspaces)

require.Equal(t, len(firstWorkspaces.Workspaces), 1, "should be 1 workspace present")

memberView, _ := coderdtest.CreateAnotherUser(t, client, otherOrg.ID)

memberViewWorkspaces, err := memberView.Workspaces(ctx, codersdk.WorkspaceFilter{})

require.NoError(t, err, "(member) fetch workspaces")

require.Equal(t, 0, len(memberViewWorkspaces.Workspaces), "member in other org should see 0 workspaces")

}

func TestPostWorkspacesByOrganization(t *testing.T) {

t.Parallel()

t.Run("InvalidTemplate", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, nil)

user := coderdtest.CreateFirstUser(t, client)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

_, err := client.CreateWorkspace(ctx, user.OrganizationID, codersdk.Me, codersdk.CreateWorkspaceRequest{

TemplateID: uuid.New(),

Name: "workspace",

})

require.Error(t, err)

var apiErr *codersdk.Error

require.ErrorAs(t, err, &apiErr)

require.Equal(t, http.StatusBadRequest, apiErr.StatusCode())

})

t.Run("NoTemplateAccess", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, nil)

first := coderdtest.CreateFirstUser(t, client)

other, _ := coderdtest.CreateAnotherUser(t, client, first.OrganizationID, rbac.RoleMember(), rbac.RoleOwner())

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

org, err := other.CreateOrganization(ctx, codersdk.CreateOrganizationRequest{

Name: "another",

})

require.NoError(t, err)

version := coderdtest.CreateTemplateVersion(t, other, org.ID, nil)

template := coderdtest.CreateTemplate(t, other, org.ID, version.ID)

_, err = client.CreateWorkspace(ctx, first.OrganizationID, codersdk.Me, codersdk.CreateWorkspaceRequest{

TemplateID: template.ID,

Name: "workspace",

})

require.Error(t, err)

var apiErr *codersdk.Error

require.ErrorAs(t, err, &apiErr)

require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())

})

t.Run("AlreadyExists", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

_, err := client.CreateWorkspace(ctx, user.OrganizationID, codersdk.Me, codersdk.CreateWorkspaceRequest{

TemplateID: template.ID,

Name: workspace.Name,

})

require.Error(t, err)

var apiErr *codersdk.Error

require.ErrorAs(t, err, &apiErr)

require.Equal(t, http.StatusConflict, apiErr.StatusCode())

})

t.Run("Create", func(t *testing.T) {

t.Parallel()

auditor := audit.NewMock()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true, Auditor: auditor})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

require.Len(t, auditor.AuditLogs, 5)

assert.Equal(t, database.AuditActionCreate, auditor.AuditLogs[4].Action)

})

t.Run("CreateWithDeletedTemplate", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

err := client.DeleteTemplate(ctx, template.ID)

require.NoError(t, err)

_, err = client.CreateWorkspace(ctx, user.OrganizationID, codersdk.Me, codersdk.CreateWorkspaceRequest{

TemplateID: template.ID,

Name: "testing",

})

require.Error(t, err)

var apiErr *codersdk.Error

require.ErrorAs(t, err, &apiErr)

require.Equal(t, http.StatusNotFound, apiErr.StatusCode())

})

t.Run("TemplateNoTTL", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID, func(ctr *codersdk.CreateTemplateRequest) {

ctr.DefaultTTLMillis = ptr.Ref(int64(0))

})

// Given: the template has no default TTL set

require.Zero(t, template.DefaultTTLMillis)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

// When: we create a workspace with autostop not enabled

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID, func(cwr *codersdk.CreateWorkspaceRequest) {

cwr.TTLMillis = ptr.Ref(int64(0))

})

// Then: No TTL should be set by the template

require.Nil(t, workspace.TTLMillis)

})

t.Run("TemplateCustomTTL", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

templateTTL := 24 * time.Hour.Milliseconds()

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID, func(ctr *codersdk.CreateTemplateRequest) {

ctr.DefaultTTLMillis = ptr.Ref(templateTTL)

})

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID, func(cwr *codersdk.CreateWorkspaceRequest) {

cwr.TTLMillis = nil // ensure that no default TTL is set

})

// TTL should be set by the template

require.Equal(t, template.DefaultTTLMillis, templateTTL)

require.Equal(t, template.DefaultTTLMillis, template.DefaultTTLMillis, workspace.TTLMillis)

})

t.Run("InvalidTTL", func(t *testing.T) {

t.Parallel()

t.Run("BelowMin", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

req := codersdk.CreateWorkspaceRequest{

TemplateID: template.ID,

Name: "testing",

TTLMillis: ptr.Ref((59 * time.Second).Milliseconds()),

}

_, err := client.CreateWorkspace(ctx, template.OrganizationID, codersdk.Me, req)

require.Error(t, err)

var apiErr *codersdk.Error

require.ErrorAs(t, err, &apiErr)

require.Equal(t, http.StatusBadRequest, apiErr.StatusCode())

require.Len(t, apiErr.Validations, 1)

require.Equal(t, apiErr.Validations[0].Field, "ttl_ms")

require.Equal(t, "time until shutdown must be at least one minute", apiErr.Validations[0].Detail)

})

})

t.Run("TemplateDefaultTTL", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

exp := 24 * time.Hour.Milliseconds()

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID, func(ctr *codersdk.CreateTemplateRequest) {

ctr.DefaultTTLMillis = &exp

})

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// no TTL provided should use template default

req := codersdk.CreateWorkspaceRequest{

TemplateID: template.ID,

Name: "testing",

}

ws, err := client.CreateWorkspace(ctx, template.OrganizationID, codersdk.Me, req)

require.NoError(t, err)

require.EqualValues(t, exp, *ws.TTLMillis)

// TTL provided should override template default

req.Name = "testing2"

exp = 1 * time.Hour.Milliseconds()

req.TTLMillis = &exp

ws, err = client.CreateWorkspace(ctx, template.OrganizationID, codersdk.Me, req)

require.NoError(t, err)

require.EqualValues(t, exp, *ws.TTLMillis)

})

}

func TestWorkspaceByOwnerAndName(t *testing.T) {

t.Parallel()

t.Run("NotFound", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, nil)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

_, err := client.WorkspaceByOwnerAndName(ctx, codersdk.Me, "something", codersdk.WorkspaceOptions{})

var apiErr *codersdk.Error

require.ErrorAs(t, err, &apiErr)

require.Equal(t, http.StatusUnauthorized, apiErr.StatusCode())

})

t.Run("Get", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

_, err := client.WorkspaceByOwnerAndName(ctx, codersdk.Me, workspace.Name, codersdk.WorkspaceOptions{})

require.NoError(t, err)

})

t.Run("Deleted", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// Given:

// We delete the workspace

build, err := client.CreateWorkspaceBuild(ctx, workspace.ID, codersdk.CreateWorkspaceBuildRequest{

Transition: codersdk.WorkspaceTransitionDelete,

})

require.NoError(t, err, "delete the workspace")

coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)

// Then:

// When we call without includes_deleted, we don't expect to get the workspace back

_, err = client.WorkspaceByOwnerAndName(ctx, workspace.OwnerName, workspace.Name, codersdk.WorkspaceOptions{})

require.ErrorContains(t, err, "404")

// Then:

// When we call with includes_deleted, we should get the workspace back

workspaceNew, err := client.WorkspaceByOwnerAndName(ctx, workspace.OwnerName, workspace.Name, codersdk.WorkspaceOptions{IncludeDeleted: true})

require.NoError(t, err)

require.Equal(t, workspace.ID, workspaceNew.ID)

// Given:

// We recreate the workspace with the same name

workspace, err = client.CreateWorkspace(ctx, user.OrganizationID, codersdk.Me, codersdk.CreateWorkspaceRequest{

TemplateID: workspace.TemplateID,

Name: workspace.Name,

AutostartSchedule: workspace.AutostartSchedule,

TTLMillis: workspace.TTLMillis,

})

require.NoError(t, err)

coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)

// Then:

// We can fetch the most recent workspace

workspaceNew, err = client.WorkspaceByOwnerAndName(ctx, workspace.OwnerName, workspace.Name, codersdk.WorkspaceOptions{})

require.NoError(t, err)

require.Equal(t, workspace.ID, workspaceNew.ID)

// Given:

// We delete the workspace again

build, err = client.CreateWorkspaceBuild(ctx, workspace.ID, codersdk.CreateWorkspaceBuildRequest{

Transition: codersdk.WorkspaceTransitionDelete,

})

require.NoError(t, err, "delete the workspace")

coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)

// Then:

// When we fetch the deleted workspace, we get the most recently deleted one

workspaceNew, err = client.WorkspaceByOwnerAndName(ctx, workspace.OwnerName, workspace.Name, codersdk.WorkspaceOptions{IncludeDeleted: true})

require.NoError(t, err)

require.Equal(t, workspace.ID, workspaceNew.ID)

})

}

// TestWorkspaceFilter creates a set of workspaces, users, and organizations

// to run various filters against for testing.

func TestWorkspaceFilter(t *testing.T) {

t.Parallel()

// Manual tests still occur below, so this is safe to disable.

t.Skip("This test is slow and flaky. See: https://github.com/coder/coder/issues/2854")

// nolint:unused

type coderUser struct {

*codersdk.Client

User codersdk.User

Org codersdk.Organization

}

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

first := coderdtest.CreateFirstUser(t, client)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

t.Cleanup(cancel)

users := make([]coderUser, 0)

for i := 0; i < 10; i++ {

userClient, user := coderdtest.CreateAnotherUser(t, client, first.OrganizationID, rbac.RoleOwner())

if i%3 == 0 {

var err error

user, err = client.UpdateUserProfile(ctx, user.ID.String(), codersdk.UpdateUserProfileRequest{

Username: strings.ToUpper(user.Username),

})

require.NoError(t, err, "uppercase username")

}

org, err := userClient.CreateOrganization(ctx, codersdk.CreateOrganizationRequest{

Name: user.Username + "-org",

})

require.NoError(t, err, "create org")

users = append(users, coderUser{

Client: userClient,

User: user,

Org: org,

})

}

type madeWorkspace struct {

Owner codersdk.User

Workspace codersdk.Workspace

Template codersdk.Template

}

availTemplates := make([]codersdk.Template, 0)

allWorkspaces := make([]madeWorkspace, 0)

upperTemplates := make([]string, 0)

// Create some random workspaces

var count int

for i, user := range users {

version := coderdtest.CreateTemplateVersion(t, client, user.Org.ID, nil)

// Create a template & workspace in the user's org

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

var template codersdk.Template

if i%3 == 0 {

template = coderdtest.CreateTemplate(t, client, user.Org.ID, version.ID, func(request *codersdk.CreateTemplateRequest) {

request.Name = strings.ToUpper(request.Name)

})

upperTemplates = append(upperTemplates, template.Name)

} else {

template = coderdtest.CreateTemplate(t, client, user.Org.ID, version.ID)

}

availTemplates = append(availTemplates, template)

workspace := coderdtest.CreateWorkspace(t, user.Client, template.OrganizationID, template.ID, func(request *codersdk.CreateWorkspaceRequest) {

if count%3 == 0 {

request.Name = strings.ToUpper(request.Name)

}

})

allWorkspaces = append(allWorkspaces, madeWorkspace{

Workspace: workspace,

Template: template,

Owner: user.User,

})

// Make a workspace with a random template

idx, _ := cryptorand.Intn(len(availTemplates))

randTemplate := availTemplates[idx]

randWorkspace := coderdtest.CreateWorkspace(t, user.Client, randTemplate.OrganizationID, randTemplate.ID)

allWorkspaces = append(allWorkspaces, madeWorkspace{

Workspace: randWorkspace,

Template: randTemplate,

Owner: user.User,

})

}

// Make sure all workspaces are done. Do it after all are made

for i, w := range allWorkspaces {

latest := coderdtest.AwaitWorkspaceBuildJob(t, client, w.Workspace.LatestBuild.ID)

allWorkspaces[i].Workspace.LatestBuild = latest

}

// --- Setup done ---

testCases := []struct {

Name string

Filter codersdk.WorkspaceFilter

// If FilterF is true, we include it in the expected results

FilterF func(f codersdk.WorkspaceFilter, workspace madeWorkspace) bool

}{

{

Name: "All",

Filter: codersdk.WorkspaceFilter{},

FilterF: func(_ codersdk.WorkspaceFilter, _ madeWorkspace) bool {

return true

},

},

{

Name: "Owner",

Filter: codersdk.WorkspaceFilter{

Owner: strings.ToUpper(users[2].User.Username),

},

FilterF: func(f codersdk.WorkspaceFilter, workspace madeWorkspace) bool {

return strings.EqualFold(workspace.Owner.Username, f.Owner)

},

},

{

Name: "TemplateName",

Filter: codersdk.WorkspaceFilter{

Template: strings.ToUpper(allWorkspaces[5].Template.Name),

},

FilterF: func(f codersdk.WorkspaceFilter, workspace madeWorkspace) bool {

return strings.EqualFold(workspace.Template.Name, f.Template)

},

},

{

Name: "UpperTemplateName",

Filter: codersdk.WorkspaceFilter{

Template: upperTemplates[0],

},

FilterF: func(f codersdk.WorkspaceFilter, workspace madeWorkspace) bool {

return strings.EqualFold(workspace.Template.Name, f.Template)

},

},

{

Name: "Name",

Filter: codersdk.WorkspaceFilter{

// Use a common letter... one has to have this letter in it

Name: "a",

},

FilterF: func(f codersdk.WorkspaceFilter, workspace madeWorkspace) bool {

return strings.ContainsAny(workspace.Workspace.Name, "Aa")

},

},

{

Name: "Q-Owner/Name",

Filter: codersdk.WorkspaceFilter{

FilterQuery: allWorkspaces[5].Owner.Username + "/" + strings.ToUpper(allWorkspaces[5].Workspace.Name),

},

FilterF: func(f codersdk.WorkspaceFilter, workspace madeWorkspace) bool {

if strings.EqualFold(workspace.Owner.Username, allWorkspaces[5].Owner.Username) &&

strings.Contains(strings.ToLower(workspace.Workspace.Name), strings.ToLower(allWorkspaces[5].Workspace.Name)) {

return true

}

return false

},

},

{

Name: "Many filters",

Filter: codersdk.WorkspaceFilter{

Owner: allWorkspaces[3].Owner.Username,

Template: allWorkspaces[3].Template.Name,

Name: allWorkspaces[3].Workspace.Name,

},

FilterF: func(f codersdk.WorkspaceFilter, workspace madeWorkspace) bool {

if strings.EqualFold(workspace.Owner.Username, f.Owner) &&

strings.Contains(strings.ToLower(workspace.Workspace.Name), strings.ToLower(f.Name)) &&

strings.EqualFold(workspace.Template.Name, f.Template) {

return true

}

return false

},

},

}

for _, c := range testCases {

c := c

t.Run(c.Name, func(t *testing.T) {

t.Parallel()

workspaces, err := client.Workspaces(ctx, c.Filter)

require.NoError(t, err, "fetch workspaces")

exp := make([]codersdk.Workspace, 0)

for _, made := range allWorkspaces {

if c.FilterF(c.Filter, made) {

exp = append(exp, made.Workspace)

}

}

require.ElementsMatch(t, exp, workspaces, "expected workspaces returned")

})

}

}

// TestWorkspaceFilterManual runs some specific setups with basic checks.

func TestWorkspaceFilterManual(t *testing.T) {

t.Parallel()

t.Run("Name", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// full match

res, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{

Name: workspace.Name,

})

require.NoError(t, err)

require.Len(t, res.Workspaces, 1, workspace.Name)

require.Equal(t, workspace.ID, res.Workspaces[0].ID)

// partial match

res, err = client.Workspaces(ctx, codersdk.WorkspaceFilter{

Name: workspace.Name[1 : len(workspace.Name)-2],

})

require.NoError(t, err)

require.Len(t, res.Workspaces, 1)

require.Equal(t, workspace.ID, res.Workspaces[0].ID)

// no match

res, err = client.Workspaces(ctx, codersdk.WorkspaceFilter{

Name: "$$$$",

})

require.NoError(t, err)

require.Len(t, res.Workspaces, 0)

})

t.Run("Template", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

template2 := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template2.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// empty

res, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{})

require.NoError(t, err)

require.Len(t, res.Workspaces, 2)

// single template

res, err = client.Workspaces(ctx, codersdk.WorkspaceFilter{

Template: template.Name,

})

require.NoError(t, err)

require.Len(t, res.Workspaces, 1)

require.Equal(t, workspace.ID, res.Workspaces[0].ID)

})

t.Run("Status", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace1 := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

workspace2 := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

// wait for workspaces to be "running"

_ = coderdtest.AwaitWorkspaceBuildJob(t, client, workspace1.LatestBuild.ID)

_ = coderdtest.AwaitWorkspaceBuildJob(t, client, workspace2.LatestBuild.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// filter finds both running workspaces

ws1, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{})

require.NoError(t, err)

require.Len(t, ws1.Workspaces, 2)

// stop workspace1

build1 := coderdtest.CreateWorkspaceBuild(t, client, workspace1, database.WorkspaceTransitionStop)

_ = coderdtest.AwaitWorkspaceBuildJob(t, client, build1.ID)

// filter finds one running workspace

ws2, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{

Status: "running",

})

require.NoError(t, err)

require.Len(t, ws2.Workspaces, 1)

require.Equal(t, workspace2.ID, ws2.Workspaces[0].ID)

// stop workspace2

build2 := coderdtest.CreateWorkspaceBuild(t, client, workspace2, database.WorkspaceTransitionStop)

_ = coderdtest.AwaitWorkspaceBuildJob(t, client, build2.ID)

// filter finds no running workspaces

ws3, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{

Status: "running",

})

require.NoError(t, err)

require.Len(t, ws3.Workspaces, 0)

})

t.Run("FilterQuery", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

template2 := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template2.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// single workspace

res, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{

FilterQuery: fmt.Sprintf("template:%s %s/%s", template.Name, workspace.OwnerName, workspace.Name),

})

require.NoError(t, err)

require.Len(t, res.Workspaces, 1)

require.Equal(t, workspace.ID, res.Workspaces[0].ID)

})

t.Run("FilterQueryHasAgentConnecting", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{

IncludeProvisionerDaemon: true,

})

user := coderdtest.CreateFirstUser(t, client)

authToken := uuid.NewString()

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{

Parse: echo.ParseComplete,

ProvisionPlan: echo.ProvisionComplete,

ProvisionApply: []*proto.Provision_Response{{

Type: &proto.Provision_Response_Complete{

Complete: &proto.Provision_Complete{

Resources: []*proto.Resource{{

Name: "example",

Type: "aws_instance",

Agents: []*proto.Agent{{

Id: uuid.NewString(),

Auth: &proto.Agent_Token{

Token: authToken,

},

}},

}},

},

},

}},

})

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

res, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{

FilterQuery: fmt.Sprintf("has-agent:%s", "connecting"),

})

require.NoError(t, err)

require.Len(t, res.Workspaces, 1)

require.Equal(t, workspace.ID, res.Workspaces[0].ID)

})

t.Run("FilterQueryHasAgentConnected", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{

IncludeProvisionerDaemon: true,

})

user := coderdtest.CreateFirstUser(t, client)

authToken := uuid.NewString()

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{

Parse: echo.ParseComplete,

ProvisionPlan: echo.ProvisionComplete,

ProvisionApply: []*proto.Provision_Response{{

Type: &proto.Provision_Response_Complete{

Complete: &proto.Provision_Complete{

Resources: []*proto.Resource{{

Name: "example",

Type: "aws_instance",

Agents: []*proto.Agent{{

Id: uuid.NewString(),

Auth: &proto.Agent_Token{

Token: authToken,

},

}},

}},

},

},

}},

})

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)

agentClient := agentsdk.New(client.URL)

agentClient.SetSessionToken(authToken)

agentCloser := agent.New(agent.Options{

Client: agentClient,

Logger: slogtest.Make(t, nil).Named("agent").Leveled(slog.LevelDebug),

})

defer func() {

_ = agentCloser.Close()

}()

coderdtest.AwaitWorkspaceAgents(t, client, workspace.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

res, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{

FilterQuery: fmt.Sprintf("has-agent:%s", "connected"),

})

require.NoError(t, err)

require.Len(t, res.Workspaces, 1)

require.Equal(t, workspace.ID, res.Workspaces[0].ID)

})

t.Run("FilterQueryHasAgentTimeout", func(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{

IncludeProvisionerDaemon: true,

})

user := coderdtest.CreateFirstUser(t, client)

authToken := uuid.NewString()

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{

Parse: echo.ParseComplete,

ProvisionPlan: echo.ProvisionComplete,

ProvisionApply: []*proto.Provision_Response{{

Type: &proto.Provision_Response_Complete{

Complete: &proto.Provision_Complete{

Resources: []*proto.Resource{{

Name: "example",

Type: "aws_instance",

Agents: []*proto.Agent{{

Id: uuid.NewString(),

Auth: &proto.Agent_Token{

Token: authToken,

},

ConnectionTimeoutSeconds: 1,

}},

}},

},

},

}},

})

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)

defer cancel()

testutil.Eventually(ctx, t, func(ctx context.Context) (done bool) {

workspaces, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{

FilterQuery: fmt.Sprintf("has-agent:%s", "timeout"),

})

require.NoError(t, err)

return workspaces.Count == 1

}, testutil.IntervalMedium, "agent status timeout")

})

}

func TestOffsetLimit(t *testing.T) {

t.Parallel()

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})

user := coderdtest.CreateFirstUser(t, client)

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)

coderdtest.AwaitTemplateVersionJob(t, client, version.ID)

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)

// empty finds all workspaces

ws, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{})

require.NoError(t, err)

require.Len(t, ws.Workspaces, 3)

// offset 1 finds 2 workspaces

ws, err = client.Workspaces(ctx, codersdk.WorkspaceFilter{

Offset: 1,

})

require.NoError(t, err)

require.Len(t, ws.Workspaces, 2)

// offset 1 limit 1 finds 1 workspace

ws, err = client.Workspaces(ctx, codersdk.WorkspaceFilter{

Offset: 1,

Limit: 1,